import os
print(os.environ.get('SLURM_JOB_NODELIST'))

ravg1001

import torch
import einops
from fancy_einsum import einsum
from dataclasses import dataclass
from transformer_lens import HookedTransformer, HookedTransformerConfig, utils
import torch.nn as nn
import numpy as np
import math
from transformer_lens.utils import get_corner, gelu_new, tokenize_and_concatenate
import tqdm.auto as tqdm
import seaborn as sns
import matplotlib.pyplot as plt
from torch.utils.data import DataLoader, Dataset
import pandas as pd
from torch.optim import Adam
from torch.nn import CrossEntropyLoss
import seaborn as sns
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, confusion_matrix, ConfusionMatrixDisplay
from transformer_lens.utils import get_act_name
#from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from typing import List, Tuple
import torch.nn.functional as F
import time
%matplotlib inline

/u/kamu/.local/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html
  from .autonotebook import tqdm as notebook_tqdm

# Move the model to the GPU for faster processing

device = "cuda" if torch.cuda.is_available() else "cpu"
device

'cuda'

#Emotion

df_train = pd.read_csv('~/transformers_play/emotional_dataset/training.csv')
print(df_train)

df_test = pd.read_csv('~/transformers_play/emotional_dataset/test.csv')
print(df_test)

df_val = pd.read_csv('~/transformers_play/emotional_dataset/validation.csv')
print(df_val)

#IMDB sentiment

df_senti = pd.read_csv('~/transformers_play/emotional_dataset/IMDB_Dataset.csv')
print(df_senti.columns)
print(df_senti)

                                                    text  label
0                                i didnt feel humiliated      0
1      i can go from feeling so hopeless to so damned...      0
2       im grabbing a minute to post i feel greedy wrong      3
3      i am ever feeling nostalgic about the fireplac...      2
4                                   i am feeling grouchy      3
...                                                  ...    ...
15995  i just had a very brief time in the beanbag an...      0
15996  i am now turning and i feel pathetic that i am...      0
15997                     i feel strong and good overall      1
15998  i feel like this was such a rude comment and i...      3
15999  i know a lot but i feel so stupid because i ca...      0

[16000 rows x 2 columns]
                                                   text  label
0     im feeling rather rotten so im not very ambiti...      0
1             im updating my blog because i feel shitty      0
2     i never make her separate from me because i do...      0
3     i left with my bouquet of red and yellow tulip...      1
4       i was feeling a little vain when i did this one      0
...                                                 ...    ...
1995  i just keep feeling like someone is being unki...      3
1996  im feeling a little cranky negative after this...      3
1997  i feel that i am useful to my people and that ...      1
1998  im feeling more comfortable with derby i feel ...      1
1999  i feel all weird when i have to meet w people ...      4

[2000 rows x 2 columns]
                                                   text  label
0     im feeling quite sad and sorry for myself but ...      0
1     i feel like i am still looking at a blank canv...      0
2                        i feel like a faithful servant      2
3                     i am just feeling cranky and blue      3
4     i can have for a treat or if i am feeling festive      1
...                                                 ...    ...
1995  im having ssa examination tomorrow in the morn...      0
1996  i constantly worry about their fight against n...      1
1997  i feel its important to share this info for th...      1
1998  i truly feel that if you are passionate enough...      1
1999  i feel like i just wanna buy any cute make up ...      1

[2000 rows x 2 columns]
Index(['review', 'sentiment'], dtype='object')
                                                  review sentiment
0      One of the other reviewers has mentioned that ...  positive
1      A wonderful little production. <br /><br />The...  positive
2      I thought this was a wonderful way to spend ti...  positive
3      Basically there's a family where a little boy ...  negative
4      Petter Mattei's "Love in the Time of Money" is...  positive
...                                                  ...       ...
49995  I thought this movie did a down right good job...  positive
49996  Bad plot, bad dialogue, bad acting, idiotic di...  negative
49997  I am a Catholic taught in parochial elementary...  negative
49998  I'm going to have to disagree with the previou...  negative
49999  No one expects the Star Trek movies to be high...  negative

[50000 rows x 2 columns]

if df_train['text'].isna().sum() > 0:
    print("Warning: Some text entries are missing.")
    df_train = df_train.dropna(subset=['text'])

emotion_labels = {
    'sadness': 0,
    'joy': 1,
    'love': 2,
    'anger': 3,
    'fear': 4,
    'surprise': 5
}


id_to_emotion = {id: label for label, id in emotion_labels.items()}

# Apply the inverse mapping to a new column for easy viewing
df_train['emotion_name'],df_test['emotion_name']  = df_train['label'].map(id_to_emotion), df_test['label'].map(id_to_emotion)

# Display the DataFrame to see both the integer label and the emotion name
df_train, df_test

# Filter for the first 20 rows
df_test_short = df_test[:50]

# Create a mapping from ID to name for printing
emotion_names = {v: k for k, v in emotion_labels.items()}

senti_labels = {
    'positive': 0,
    'negative': 1 }


id_to_senti = {id: sentiment for sentiment, id in senti_labels.items()}


# Create a mapping from ID to name for printing

senti_names = {v: k for k, v in senti_labels.items()}


X = df_senti['review']
y = df_senti['sentiment']

# Split the data into training and testing sets.

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.8, random_state=42)

from huggingface_hub import login


# Log in to Hugging Face
login(token="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")

# Define the model name
model_name = "meta-llama/Llama-2-7b-chat-hf"

# Now load the model
try:
    model_llama = HookedTransformer.from_pretrained(model_name, fold_ln=False, center_unembed=False, center_writing_weights=False)
    print(f"Loaded {model_name} successfully.")
    
except Exception as e:
    print(f"An error occurred: {e}")

Loading checkpoint shards: 100%|██████████| 2/2 [00:40<00:00, 20.17s/it]

Loaded pretrained model meta-llama/Llama-2-7b-chat-hf into HookedTransformer
Loaded meta-llama/Llama-2-7b-chat-hf successfully.

tokenizer = model_llama.tokenizer
tokenizer

LlamaTokenizerFast(name_or_path='meta-llama/Llama-2-7b-chat-hf', vocab_size=32000, model_max_length=1000000000000000019884624838656, is_fast=True, padding_side='right', truncation_side='right', special_tokens={'bos_token': '<s>', 'eos_token': '</s>', 'unk_token': '<unk>', 'pad_token': '</s>'}, clean_up_tokenization_spaces=False, added_tokens_decoder={
	0: AddedToken("<unk>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	1: AddedToken("<s>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	2: AddedToken("</s>", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
}
)

print("\n--- Zero-Shot vs. Constraint-Based Prompting Comparison ---")
print("This will process the same text with two different prompts to compare the results.")

true_emotions = []
predicted_emotions = []

results_list = []

for i, row in df_test[:].iterrows():
    
    text = row['text']
    true_label_id = row['label']
    true_label_name = row['emotion_name'] #emotion_names.get(true_label_id, "unknown")

    # --- Case 1: Zero-Shot Prompting ---
    
    zero_shot_prompt = f"{text}\nWhat is the emotion of this text? Choose from sadness, joy, love, anger, fear, surprise."

    # Tokenize and move to GPU
    
    inputs_zero = tokenizer(zero_shot_prompt, return_tensors="pt")
    if torch.cuda.is_available():
        inputs_zero = {k: v.to('cuda') for k, v in inputs_zero.items()}
    
    # Generate the next 10 tokens
    
    output_tokens_zero = model_llama.generate(
        inputs_zero['input_ids'],
        max_new_tokens=10,
        do_sample=False,
    )

    # Isolate the newly generated tokens for the zero-shot case
    
    new_tokens_zero = tokenizer.decode(output_tokens_zero[0][inputs_zero['input_ids'].shape[1]:], skip_special_tokens=True)
    
    # Extract the predicted emotion from the generated text
    
    predicted_zero_shot = "unknown"
    
    for emotion_name in emotion_labels.keys():
        
        if emotion_name in new_tokens_zero.lower():
            
            predicted_zero_shot = emotion_name
            
            break

    # --- Case 2: Constraint-Based Prompting ---
    
    constraint_prompt = f"{text}\nWhat is the single emotion of this text? You must choose one and only one from the following list: sadness, joy, love, anger, fear, surprise. The emotion is:"

    # Tokenize and move to GPU
    
    inputs_constraint = tokenizer(constraint_prompt, return_tensors="pt")
    if torch.cuda.is_available():
        inputs_constraint = {k: v.to('cuda') for k, v in inputs_constraint.items()}
    
    # Generate the next 10 tokens
    
    output_tokens_constraint = model_llama.generate(
        inputs_constraint['input_ids'],
        max_new_tokens=10,
        do_sample=False,
    )

    # Isolate the newly generated tokens for the constraint-based case
    
    predicted_new_tokens_constraint = tokenizer.decode(output_tokens_constraint[0][inputs_constraint['input_ids'].shape[1]:], skip_special_tokens=True)

    # Extract the predicted emotion from the generated text
    
    predicted_constraint = "unknown"
    
    cleaned_output = predicted_new_tokens_constraint.strip().lower()
    
    for word in cleaned_output.replace("a. ", "").replace("b. ", "").replace("\n", " ").split():
        
        clean_word = word.strip(".,:;").lower()
        
        if clean_word in emotion_labels.keys():
            
            predicted_constraint = clean_word
            
            break
     
    true_emotions.append(true_label_name)
    predicted_emotions.append(predicted_constraint)#predicted_emotions.append(cleaned_output)
    
    status = 1 if true_label_name == predicted_constraint else 0


    results_list.append({
            'text': text,
            'emotion': true_label_name,
            'constrained prompt': f"{text}\nWhat the single emotion of this text? You must choose one and only one from the following list: sadness, joy, love, anger, fear, surprise. The emotion is:",
            'prompt response' : cleaned_output,
            'predicted emotion': predicted_constraint,
            'Output status': status
            
        })        

    # --- Print Comparison Results ---
    
    
    print(f"\n--- Text {i+1} ---")
    print(f"Text: '{text}'")
    print(f"True Emotion: {true_label_name}")
    
    print("\n--- Zero-Shot Prompting ---")
    
    print(f"Prompt: {zero_shot_prompt}")
    print(f"Generated Output: {new_tokens_zero.strip()}")
    print(f"Predicted Emotion: {predicted_zero_shot}")
    
    print("\n--- Constraint-Based Prompting ---")
    
    print(f"Prompt: {constraint_prompt}")
    print(f"Generated Output: {predicted_new_tokens_constraint.strip()}")
    print(f"Predicted Emotion: {predicted_constraint}")
    print("-" * 20)

--- Zero-Shot vs. Constraint-Based Prompting Comparison ---
This will process the same text with two different prompts to compare the results.

  0%|          | 0/10 [00:00<?, ?it/s]
 50%|█████     | 5/10 [00:00<00:00, 13.31it/s]

--- Text 1 ---
Text: 'im feeling rather rotten so im not very ambitious right now'
True Emotion: sadness

--- Zero-Shot Prompting ---
Prompt: im feeling rather rotten so im not very ambitious right now
What is the emotion of this text? Choose from sadness, joy, love, anger, fear, surprise.
Generated Output: 
Predicted Emotion: unknown

--- Constraint-Based Prompting ---
Prompt: im feeling rather rotten so im not very ambitious right now
What is the single emotion of this text? You must choose one and only one from the following list: sadness, joy, love, anger, fear, surprise. The emotion is:
Generated Output: sadness
Predicted Emotion: sadness
--------------------

  0%|          | 0/10 [00:00<?, ?it/s]
 50%|█████     | 5/10 [00:00<00:00, 12.70it/s]

--- Text 2 ---
Text: 'im updating my blog because i feel shitty'
True Emotion: sadness

--- Zero-Shot Prompting ---
Prompt: im updating my blog because i feel shitty
What is the emotion of this text? Choose from sadness, joy, love, anger, fear, surprise.
Generated Output: 
Predicted Emotion: unknown

--- Constraint-Based Prompting ---
Prompt: im updating my blog because i feel shitty
What is the single emotion of this text? You must choose one and only one from the following list: sadness, joy, love, anger, fear, surprise. The emotion is:
Generated Output: sadness
Predicted Emotion: sadness
--------------------

  0%|          | 0/10 [00:00<?, ?it/s]
 20%|██        | 2/10 [00:00<00:00,  8.58it/s]

--- Text 3 ---
Text: 'i never make her separate from me because i don t ever want her to feel like i m ashamed with her'
True Emotion: sadness

--- Zero-Shot Prompting ---
Prompt: i never make her separate from me because i don t ever want her to feel like i m ashamed with her
What is the emotion of this text? Choose from sadness, joy, love, anger, fear, surprise.
Generated Output: 
Predicted Emotion: unknown

--- Constraint-Based Prompting ---
Prompt: i never make her separate from me because i don t ever want her to feel like i m ashamed with her
What is the single emotion of this text? You must choose one and only one from the following list: sadness, joy, love, anger, fear, surprise. The emotion is:
Generated Output: love.
Predicted Emotion: love
--------------------

  0%|          | 0/10 [00:00<?, ?it/s]
 50%|█████     | 5/10 [00:00<00:00, 12.93it/s]

--- Text 4 ---
Text: 'i left with my bouquet of red and yellow tulips under my arm feeling slightly more optimistic than when i arrived'
True Emotion: joy

--- Zero-Shot Prompting ---
Prompt: i left with my bouquet of red and yellow tulips under my arm feeling slightly more optimistic than when i arrived
What is the emotion of this text? Choose from sadness, joy, love, anger, fear, surprise.
Generated Output: 
Predicted Emotion: unknown

--- Constraint-Based Prompting ---
Prompt: i left with my bouquet of red and yellow tulips under my arm feeling slightly more optimistic than when i arrived
What is the single emotion of this text? You must choose one and only one from the following list: sadness, joy, love, anger, fear, surprise. The emotion is:
Generated Output: Optimism
Predicted Emotion: unknown
--------------------

  0%|          | 0/10 [00:00<?, ?it/s]
100%|██████████| 10/10 [00:00<00:00, 17.26it/s]

df_constrained_prompt = pd.DataFrame(results_list)
df_constrained_prompt

df_constrained_prompt.to_csv('constrained_prompt_results_llama2.csv', index=False)

print("DataFrame saved successfully to 'constrained_prompt_results.csv'")

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[10], line 2
      1 # Save the DataFrame to a CSV file
----> 2 df_constrained_prompt.to_csv('constrained_prompt_results_llama2.csv', index=False)
      4 print("DataFrame saved successfully to 'constrained_prompt_results.csv'")

NameError: name 'df_constrained_prompt' is not defined

try:
   
    df_constrained_prompt_loaded = pd.read_csv('constrained_prompt_results_llama2.csv')
    
    print("DataFrame loaded successfully.")
    print( df_constrained_prompt_loaded.head())

except FileNotFoundError:
    print("The file 'constrained_prompt_results.csv' was not found.")

DataFrame loaded successfully.
                                                text  emotion  \
0  im feeling rather rotten so im not very ambiti...  sadness   
1          im updating my blog because i feel shitty  sadness   
2  i never make her separate from me because i do...  sadness   
3  i left with my bouquet of red and yellow tulip...      joy   
4    i was feeling a little vain when i did this one  sadness   

                                  constrained prompt  \
0  im feeling rather rotten so im not very ambiti...   
1  im updating my blog because i feel shitty\nWha...   
2  i never make her separate from me because i do...   
3  i left with my bouquet of red and yellow tulip...   
4  i was feeling a little vain when i did this on...   

                      prompt response predicted emotion  Output status  
0                             sadness           sadness              1  
1                             sadness           sadness              1  
2                               love.              love              0  
3                            optimism           unknown              0  
4  i was feeling a little vain when i           unknown              0

print("\n--- Generating Performance Histogram ---")
plt.figure(figsize=(8, 6))
# The bins are set to center the bars at 0 and 1

df_constrained_prompt_loaded['Output status'].hist( align='mid', rwidth=0.8)

plt.xticks([0, 1], ['Hallucinated', 'Non hallucinated'])
plt.title('Prediction Status: Hallucinated(0) vs. Non hallucinated (1)')
plt.xlabel('Prediction Status')
plt.ylabel('Number of Instances')
plt.show()

--- Generating Performance Histogram ---

# Calculate and print the overall accuracy

true_emotions = df_constrained_prompt_loaded['emotion']
predicted_emotions = df_constrained_prompt_loaded['predicted emotion']


try:
    accuracy = accuracy_score(true_emotions, predicted_emotions)
    print("\n--- Overall Accuracy ---")
    print(f"Accuracy: {accuracy:.2f}")
except Exception as e:
    print(f"\nCould not calculate accuracy: {e}")

--- Overall Accuracy ---
Accuracy: 0.39

# Create and display a confusion matrix to visualize errors

print("\n--- Generating Confusion Matrix ---")
cm = confusion_matrix(true_emotions, predicted_emotions, labels=list(set(true_emotions)))
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=list(set(true_emotions)))
disp.plot(cmap=plt.cm.Blues)
plt.title('Confusion Matrix')
plt.show()

--- Generating Confusion Matrix ---

hallu_df = df_constrained_prompt_loaded[df_constrained_prompt_loaded['Output status'] == 0].copy()

non_hallu_df = df_constrained_prompt_loaded[df_constrained_prompt_loaded['Output status'] == 1].copy()

hallu_df

hallucination_patterns = hallu_df.groupby(['emotion', 'predicted emotion']).size().reset_index(name='count')
    

hallucination_patterns = hallucination_patterns.sort_values(by='count', ascending=False)
    

hallucination_patterns

hallu_set1_df = hallu_df[(hallu_df['emotion'] == 'joy') & (hallu_df['predicted emotion'] == 'sadness')]


hallu_set2_df = hallu_df[(hallu_df['emotion'] == 'joy') & (hallu_df['predicted emotion'] == 'love')]


hallu_set3_df = hallu_df[(hallu_df['emotion'] == 'joy') & (hallu_df['predicted emotion'] == 'fear')]


hallu_set4_df = hallu_df[(hallu_df['emotion'] == 'joy') & (hallu_df['predicted emotion'] == 'surprise')]


hallu_set5_df = hallu_df[(hallu_df['emotion'] == 'joy') & (hallu_df['predicted emotion'] == 'anger')]






hallu_set6_df = hallu_df[(hallu_df['emotion'] == 'anger') & (hallu_df['predicted emotion'] == 'sadness')]


hallu_set7_df = hallu_df[(hallu_df['emotion'] == 'anger') & (hallu_df['predicted emotion'] == 'joy')]


hallu_set8_df = hallu_df[(hallu_df['emotion'] == 'anger') & (hallu_df['predicted emotion'] == 'fear')]


hallu_set9_df = hallu_df[(hallu_df['emotion'] == 'anger') & (hallu_df['predicted emotion'] == 'love')]


hallu_set10_df = hallu_df[(hallu_df['emotion'] == 'anger') & (hallu_df['predicted emotion'] == 'surprise')]








hallu_set11_df = hallu_df[(hallu_df['emotion'] == 'sadness') & (hallu_df['predicted emotion'] == 'fear')]


hallu_set12_df = hallu_df[(hallu_df['emotion'] == 'sadness') & (hallu_df['predicted emotion'] == 'love')]


hallu_set13_df = hallu_df[(hallu_df['emotion'] == 'sadness') & (hallu_df['predicted emotion'] == 'surprise')]


hallu_set14_df = hallu_df[(hallu_df['emotion'] == 'sadness') & (hallu_df['predicted emotion'] == 'joy')]


hallu_set15_df = hallu_df[(hallu_df['emotion'] == 'sadness') & (hallu_df['predicted emotion'] == 'anger')]






hallu_set16_df = hallu_df[(hallu_df['emotion'] == 'fear') & (hallu_df['predicted emotion'] == 'sadness')]


hallu_set17_df = hallu_df[(hallu_df['emotion'] == 'fear') & (hallu_df['predicted emotion'] == 'love')]


hallu_set18_df = hallu_df[(hallu_df['emotion'] == 'fear') & (hallu_df['predicted emotion'] == 'anger')]


hallu_set19_df = hallu_df[(hallu_df['emotion'] == 'fear') & (hallu_df['predicted emotion'] == 'surprise')]


hallu_set20_df = hallu_df[(hallu_df['emotion'] == 'fear') & (hallu_df['predicted emotion'] == 'joy')]



hallu_set_unkown_df = hallu_df[(hallu_df['emotion'] == 'joy') & (hallu_df['predicted emotion'] == 'unknown')]

import os
from typing import List

def generate_and_save_caches(model, tokenizer, hallu_dfs: List[pd.DataFrame], save_dir: str = "cached_data"):
    """
    Runs the model on all prompts and saves the original logits and caches to disk.
    
    This is an memory-efficient method for large datasets.
    
    Args:
        model: The loaded TransformerLens model.
        tokenizer: The tokenizer for the model.
        hallu_dfs (List[pd.DataFrame]): A list of DataFrames, each containing hallucinating prompts.
        save_dir (str): The directory where the caches will be saved.
    """
    if not os.path.exists(save_dir):
        os.makedirs(save_dir)

    all_prompts_df = pd.concat(hallu_dfs, ignore_index=True)

    for index, row in all_prompts_df.iterrows():
        prompt = row['constrained prompt']
        
        
        cache_filepath = os.path.join(save_dir, f"cache_{index}.pt")
        logits_filepath = os.path.join(save_dir, f"logits_{index}.pt")
        
        if os.path.exists(cache_filepath) and os.path.exists(logits_filepath):
            print(f"Skipping index {index}, files already exist.")
            continue
            
        print(f"Processing prompt {index}...")
        
        with torch.no_grad():
            try:
                logits, cache = model.run_with_cache(prompt)
                
                
                torch.save(logits, logits_filepath)
                torch.save(cache, cache_filepath)
                
               
                del logits, cache
                torch.cuda.empty_cache()
            
            except RuntimeError as e:
                if "CUDA out of memory" in str(e):
                    print(f"OutOfMemoryError for prompt: {prompt}. Skipping...")
                    continue
                else:
                    raise e
    print("All caches have been generated and saved.")

#all_hallu_sample_dfs = [hallu_set1_df[:5]]

generate_and_save_caches(model_llama, tokenizer, [hallu_set1_df[:20]])

Skipping index 0, files already exist.
Skipping index 1, files already exist.
Skipping index 2, files already exist.
Skipping index 3, files already exist.
Skipping index 4, files already exist.
Skipping index 5, files already exist.
Skipping index 6, files already exist.
Skipping index 7, files already exist.
Skipping index 8, files already exist.
Skipping index 9, files already exist.
Skipping index 10, files already exist.
Skipping index 11, files already exist.
Skipping index 12, files already exist.
Skipping index 13, files already exist.
Skipping index 14, files already exist.
Skipping index 15, files already exist.
Skipping index 16, files already exist.
Skipping index 17, files already exist.
Skipping index 18, files already exist.
Skipping index 19, files already exist.
All caches have been generated and saved.

from typing import Dict

def load_saved_caches(save_dir: str = "cached_data") -> Dict:
    loaded_data = {}
    cache_files = [f for f in os.listdir(save_dir) if f.startswith('cache_') and f.endswith('.pt')]
    
    for cache_file in cache_files:
        index_str = cache_file.split('_')[1].split('.')[0]
        index = int(index_str)
        
        logits_filepath = os.path.join(save_dir, f"logits_{index}.pt")
        cache_filepath = os.path.join(save_dir, cache_file)
        
        try:
            logits = torch.load(logits_filepath)
            
            # Change this line
            cache = torch.load(cache_filepath, weights_only=False)
            
            loaded_data[index] = {'logits': logits, 'cache': cache}
        except FileNotFoundError:
            print(f"Warning: Missing logits file for index {index}. Skipping...")
            
    print(f"Loaded data for {len(loaded_data)} prompts.")
    return loaded_data

---------------------------------------------------------------------------
OutOfMemoryError                          Traceback (most recent call last)
Cell In[31], line 1
----> 1 loaded_data = load_saved_caches()
      2 # Access the data for prompt at index 4 like this:
      3 #original_cache = loaded_data[4]['cache']
      4 #original_logits = loaded_data[4]['logits']

Cell In[30], line 18, in load_saved_caches(save_dir)
     15     logits = torch.load(logits_filepath)
     17     # Change this line
---> 18     cache = torch.load(cache_filepath, weights_only=False)
     20     loaded_data[index] = {'logits': logits, 'cache': cache}
     21 except FileNotFoundError:

File ~/.local/lib/python3.10/site-packages/torch/serialization.py:1530, in load(f, map_location, pickle_module, weights_only, mmap, **pickle_load_args)
   1528             except pickle.UnpicklingError as e:
   1529                 raise pickle.UnpicklingError(_get_wo_message(str(e))) from None
-> 1530         return _load(
   1531             opened_zipfile,
   1532             map_location,
   1533             pickle_module,
   1534             overall_storage=overall_storage,
   1535             **pickle_load_args,
   1536         )
   1537 if mmap:
   1538     f_name = "" if not isinstance(f, str) else f"{f}, "

File ~/.local/lib/python3.10/site-packages/torch/serialization.py:2119, in _load(zip_file, map_location, pickle_module, pickle_file, overall_storage, **pickle_load_args)
   2117 global _serialization_tls
   2118 _serialization_tls.map_location = map_location
-> 2119 result = unpickler.load()
   2120 _serialization_tls.map_location = None
   2122 torch._utils._validate_loaded_sparse_tensors()

File ~/.local/lib/python3.10/site-packages/torch/serialization.py:2083, in _load.<locals>.persistent_load(saved_id)
   2081 else:
   2082     nbytes = numel * torch._utils._element_size(dtype)
-> 2083     typed_storage = load_tensor(
   2084         dtype, nbytes, key, _maybe_decode_ascii(location)
   2085     )
   2087 return typed_storage

File ~/.local/lib/python3.10/site-packages/torch/serialization.py:2049, in _load.<locals>.load_tensor(dtype, numel, key, location)
   2045 # TODO: Once we decide to break serialization FC, we can
   2046 # stop wrapping with TypedStorage
   2048 if torch._guards.detect_fake_mode(None) is None:
-> 2049     wrap_storage = restore_location(storage, location)
   2050 else:
   2051     storage._fake_device = location

File ~/.local/lib/python3.10/site-packages/torch/serialization.py:698, in default_restore_location(storage, location)
    678 """
    679 Restores `storage` using a deserializer function registered for the `location`.
    680 
   (...)
    695        all matching ones return `None`.
    696 """
    697 for _, _, fn in _package_registry:
--> 698     result = fn(storage, location)
    699     if result is not None:
    700         return result

File ~/.local/lib/python3.10/site-packages/torch/serialization.py:637, in _deserialize(backend_name, obj, location)
    635 if location.startswith(backend_name):
    636     device = _validate_device(location, backend_name)
--> 637     return obj.to(device=device)

File ~/.local/lib/python3.10/site-packages/torch/storage.py:291, in _StorageBase.to(self, device, non_blocking)
    289 if not isinstance(device, torch.device):
    290     device = torch.device(device)
--> 291 return _to(self, device, non_blocking)

File ~/.local/lib/python3.10/site-packages/torch/_utils.py:101, in _to(self, device, non_blocking)
     97 else:
     98     assert not self.is_sparse, (
     99         f"sparse storage is not supported for {device.type.upper()} tensors"
    100     )
--> 101     untyped_storage = torch.UntypedStorage(self.size(), device=device)
    102     untyped_storage.copy_(self, non_blocking)
    103     return untyped_storage

OutOfMemoryError: CUDA out of memory. Tried to allocate 172.00 MiB. GPU 0 has a total capacity of 39.39 GiB of which 83.06 MiB is free. Including non-PyTorch memory, this process has 39.30 GiB memory in use. Of the allocated memory 38.80 GiB is allocated by PyTorch, and 24.88 MiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)

# Run the model on the text and save all the layer activations to a cache.

text_to_analyze = hallu_df['text'].iloc[0]
    
# run_with_cache returns the final logits and a cache object.

with torch.no_grad():
    
    logits, cache = model_llama.run_with_cache(text_to_analyze)

   
print("\n--- Inspecting Activations (Cache) ---")
    


for i in range(model_llama.cfg.n_layers):
    
        
    attention_out = cache["pattern", i]
       
    print(f"Layer {i} Attention Output Shape: {attention_out.shape}") # The shape is (batch, position, head, head_size

--- Inspecting Activations (Cache) ---
Layer 0 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 1 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 2 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 3 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 4 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 5 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 6 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 7 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 8 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 9 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 10 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 11 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 12 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 13 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 14 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 15 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 16 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 17 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 18 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 19 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 20 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 21 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 22 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 23 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 24 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 25 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 26 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 27 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 28 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 29 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 30 Attention Output Shape: torch.Size([1, 32, 24, 24])
Layer 31 Attention Output Shape: torch.Size([1, 32, 24, 24])

for i,keys in enumerate(cache.keys()):
    print(i,keys)
    if i==20:
        break
   
# output of the MLP block.
layer = 1

mlp_out = cache[f'blocks.{layer}.mlp.hook_post']

print(mlp_out.shape)

print(f"Layer {layer} MLP Output Shape: {mlp_out.shape}")
print("-" * 20)

0 hook_embed
1 blocks.0.hook_resid_pre
2 blocks.0.ln1.hook_scale
3 blocks.0.ln1.hook_normalized
4 blocks.0.attn.hook_q
5 blocks.0.attn.hook_k
6 blocks.0.attn.hook_v
7 blocks.0.attn.hook_rot_q
8 blocks.0.attn.hook_rot_k
9 blocks.0.attn.hook_attn_scores
10 blocks.0.attn.hook_pattern
11 blocks.0.attn.hook_z
12 blocks.0.hook_attn_out
13 blocks.0.hook_resid_mid
14 blocks.0.ln2.hook_scale
15 blocks.0.ln2.hook_normalized
16 blocks.0.mlp.hook_pre
17 blocks.0.mlp.hook_pre_linear
18 blocks.0.mlp.hook_post
19 blocks.0.hook_mlp_out
20 blocks.0.hook_resid_post
torch.Size([1, 65, 11008])
Layer 1 MLP Output Shape: torch.Size([1, 65, 11008])
--------------------

print(hallu_df['emotion'].iloc[6])
print(hallu_df['predicted emotion'].iloc[6])
print(hallu_df['constrained prompt'].iloc[6])

anger
unknown
i jest i feel grumpy tired and pre menstrual which i probably am but then again its only been a week and im about as fit as a walrus on vacation for the summer
What the single emotion of this text? You must choose one and only one from the following list: sadness, joy, love, anger, fear, surprise. The emotion is:

def get_token_ids(tokenizer, text):
    """
    Gets the token IDs for a text string, handling spaces.
    """
    try:
        
        encoded_with_space = tokenizer.encode(f" {text}", add_special_tokens=False)
        if encoded_with_space:
            return encoded_with_space
        
        
        encoded_without_space = tokenizer.encode(text, add_special_tokens=False)
        if encoded_without_space:
            return encoded_without_space
    except Exception as e:
        print(f"Tokenization error for '{text}': {e}", file=sys.stderr)
        
    raise ValueError(f"Could not find any tokens for '{text}'.")

# --- Rank Calculation Function ---

def get_rank(logits, token_ids):
    """
    Calculates the rank of the given tokens in the logits tensor.
    Rank is 1-based, where 1 is the highest logit score.
    """
    # Sort logits in descending order and get their original indices
    sorted_indices = torch.argsort(logits, descending=True)
    
    # Find the rank of the target token(s)
    ranks = []
    for t in token_ids:
        
        if t in sorted_indices:
            rank = (sorted_indices == t).nonzero().item() + 1
            ranks.append(rank)
        else:
            
            print(f"Token ID {t} not found in logits. Returning a high rank.", file=sys.stderr)
            return len(logits) + 1 
    
    if not ranks:
        return len(logits) + 1
        
    return min(ranks)

def analyze_prompt_attention_only(model, tokenizer, prompt_df):
    """
    Analyzes a DataFrame of prompts by calculating logit scores and ranks for each layer,
    based on the output of the attention mechanism only.
    
    Args:
        model: The Llama 2 model loaded with Transformer Lens.
        tokenizer: The tokenizer.
        prompt_df : The DataFrame containing 'constrained prompt',
                                  'emotion', and 'predicted emotion' columns.
                                  
    Returns:
        pd.DataFrame: A DataFrame with the average logit scores and ranks per layer.
    """
    all_metrics = []
    
    for _, row in prompt_df.iterrows():
        try:
            true_ids = get_token_ids(tokenizer, row['emotion'])
            predicted_ids = get_token_ids(tokenizer, row['predicted emotion'])
            
            input_ids = tokenizer.encode(row['constrained prompt'], return_tensors='pt')
            final_token_idx = input_ids.shape[-1] - 1
            
            
            with torch.no_grad():
                logits, cache = model.run_with_cache(row['constrained prompt'])

            for layer_idx in range(model.cfg.n_layers):
                
                attn_out_contribution = cache[("attn_out", layer_idx)][0, final_token_idx, :]

            
                attn_logits = model.unembed(attn_out_contribution)
                
                # Sum of the logits for the true and predicted emotion tokens.
                true_logit_raw = attn_logits[true_ids].sum().item()
                predicted_logit_raw = attn_logits[predicted_ids].sum().item()
                logit_difference = predicted_logit_raw - true_logit_raw
                
                # rank for the true and predicted tokens
                true_rank = get_rank(attn_logits, true_ids)
                predicted_rank = get_rank(attn_logits, predicted_ids)
                
                all_metrics.append({
                    'layer': layer_idx,
                    'true_logit_raw': true_logit_raw,
                    'predicted_logit_raw': predicted_logit_raw,
                    'logit_difference': logit_difference
                    #'true_rank': true_rank,
                    #'predicted_rank': predicted_rank
                })
        except Exception as e:
            print(f"Skipping analysis for prompt: {row['constrained prompt']}\nError: {e}")
            continue

    if not all_metrics:
        print("No metrics were generated. The prompt DataFrame might be empty or a tokenization error occurred.")
        return pd.DataFrame()
        
    all_metrics_df = pd.DataFrame(all_metrics)
    average_metrics_df = all_metrics_df.groupby('layer').mean().reset_index()
    
    return average_metrics_df

def analyze_prompt_set_mlp_only(model, tokenizer, prompt_df):
    """
    Analyzes a DataFrame of prompts by calculating logit scores and ranks for each layer.
    
    Args:
        model (HookedTransformer): The Llama 2 model loaded with Transformer Lens.
        tokenizer: The tokenizer.
        prompt_df (pd.DataFrame): The DataFrame containing 'constrained prompt',
                                    'emotion', and 'predicted emotion' columns.
                                    
    Returns:
        pd.DataFrame: A DataFrame with the average logit scores and ranks per layer.
    """
    all_metrics = []
    
    for _, row in prompt_df.iterrows():
        try:
            true_ids = get_token_ids(tokenizer, row['emotion'])
            predicted_ids = get_token_ids(tokenizer, row['predicted emotion'])
            
            input_ids = tokenizer.encode(row['constrained prompt'], return_tensors='pt')
            final_token_idx = input_ids.shape[-1] - 1
            
           
            with torch.no_grad():
                logits, cache = model.run_with_cache(row['constrained prompt'])

            for layer_idx in range(model.cfg.n_layers):
                
                #  output of the MLP for the last token
                mlp_out_contribution = cache[("mlp_out", layer_idx)][0, final_token_idx, :]

                # MLP contribution through the unembedding matrix to get logit contribution
               
                mlp_logits = model.unembed(mlp_out_contribution)
                
                # Sum of the logits for the true and predicted emotion tokens.
                true_logit_raw = mlp_logits[true_ids].sum().item()
                predicted_logit_raw = mlp_logits[predicted_ids].sum().item()
                logit_difference = predicted_logit_raw - true_logit_raw
                
                #rank for the true and predicted tokens
                true_rank = get_rank(mlp_logits, true_ids)
                predicted_rank = get_rank(mlp_logits, predicted_ids)
                
                all_metrics.append({
                    'layer': layer_idx,
                    'true_logit_raw': true_logit_raw,
                    'predicted_logit_raw': predicted_logit_raw,
                    'logit_difference': logit_difference
                    #'true_rank': true_rank,
                    #'predicted_rank': predicted_rank
                })
        except Exception as e:
            print(f"Skipping analysis for prompt: {row['constrained prompt']}\nError: {e}")
            continue

    if not all_metrics:
        print("No metrics were generated. The prompt DataFrame might be empty or a tokenization error occurred.")
        return pd.DataFrame()
        
    all_metrics_df = pd.DataFrame(all_metrics)
    average_metrics_df = all_metrics_df.groupby('layer').mean().reset_index()
    
    return average_metrics_df

attn_avg_logit_metrics_set1 = analyze_prompt_attention_only(model_llama, model_llama.tokenizer, hallu_set1_df)

attn_avg_logit_metrics_set2 = analyze_prompt_attention_only(model_llama, model_llama.tokenizer, hallu_set2_df)

attn_avg_logit_metrics_set3 = analyze_prompt_attention_only(model_llama, model_llama.tokenizer, hallu_set3_df)

attn_avg_logit_metrics_set4 = analyze_prompt_attention_only(model_llama, model_llama.tokenizer, hallu_set4_df)

attn_avg_logit_metrics_set5 = analyze_prompt_attention_only(model_llama, model_llama.tokenizer, hallu_set5_df)

attn_avg_logit_metrics_set6 = analyze_prompt_attention_only(model_llama, model_llama.tokenizer, hallu_set6_df)

attn_avg_logit_metrics_set7 = analyze_prompt_attention_only(model_llama, model_llama.tokenizer, hallu_set7_df)

attn_avg_logit_metrics_set8 = analyze_prompt_attention_only(model_llama, model_llama.tokenizer, hallu_set8_df)

attn_avg_logit_metrics_set9 = analyze_prompt_attention_only(model_llama, model_llama.tokenizer, hallu_set9_df)

attn_avg_logit_metrics_set10 = analyze_prompt_attention_only(model_llama, model_llama.tokenizer, hallu_set10_df)

attn_avg_logit_metrics_set11 = analyze_prompt_attention_only(model_llama, model_llama.tokenizer, hallu_set11_df)

attn_avg_logit_metrics_set12 = analyze_prompt_attention_only(model_llama, model_llama.tokenizer, hallu_set12_df)

attn_avg_logit_metrics_set13 = analyze_prompt_attention_only(model_llama, model_llama.tokenizer, hallu_set13_df)

attn_avg_logit_metrics_set14 = analyze_prompt_attention_only(model_llama, model_llama.tokenizer, hallu_set14_df)

attn_avg_logit_metrics_set15 = analyze_prompt_attention_only(model_llama, model_llama.tokenizer, hallu_set15_df)

attn_avg_logit_metrics_set16 = analyze_prompt_attention_only(model_llama, model_llama.tokenizer, hallu_set16_df)

attn_avg_logit_metrics_set17 = analyze_prompt_attention_only(model_llama, model_llama.tokenizer, hallu_set17_df)

attn_avg_logit_metrics_set18 = analyze_prompt_attention_only(model_llama, model_llama.tokenizer, hallu_set18_df)

attn_avg_logit_metrics_set19 = analyze_prompt_attention_only(model_llama, model_llama.tokenizer, hallu_set19_df)

attn_avg_logit_metrics_set20 = analyze_prompt_attention_only(model_llama, model_llama.tokenizer, hallu_set20_df)

attn_avg_logit_metrics_set8

def analyze_prompt_set_single_mlp_only(model, tokenizer, prompt, true_emotion, predicted_emotion):
    """
    Analyzes a single prompt by calculating MLP logit scores and ranks for each layer.

    Args:
        model : The Llama 2 model loaded with Transformer Lens.
        tokenizer: The tokenizer.
        prompt (str): The constrained prompt text.
        true_emotion (str): The correct emotion label.
        predicted_emotion (str): The model's hallucinated emotion label.
                                        
    Returns:
        pd.DataFrame: A DataFrame with the logit scores and ranks per layer.
    """
    all_metrics = []
    
    try:
        true_ids = get_token_ids(tokenizer, true_emotion)
        predicted_ids = get_token_ids(tokenizer, predicted_emotion)
        
        input_ids = tokenizer.encode(prompt, return_tensors='pt')
        final_token_idx = input_ids.shape[-1] - 1
        
        
        with torch.no_grad():
            logits, cache = model.run_with_cache(prompt)

        for layer_idx in range(model.cfg.n_layers):
            # output of the MLP for the last token
            mlp_out_contribution = cache[("mlp_out", layer_idx)][0, final_token_idx, :]

            # MLP contribution through the unembedding matrix
            mlp_logits = model.unembed(mlp_out_contribution)
            
            # Sum of the logits for the true and predicted emotion tokens.
            true_logit_raw = mlp_logits[true_ids].sum().item()
            predicted_logit_raw = mlp_logits[predicted_ids].sum().item()
            logit_difference = predicted_logit_raw - true_logit_raw
            
            #rank for the true and predicted tokens
            true_rank = get_rank(mlp_logits, true_ids)
            predicted_rank = get_rank(mlp_logits, predicted_ids)
            
            all_metrics.append({
                'layer': layer_idx,
                'true_logit_raw': true_logit_raw,
                'predicted_logit_raw': predicted_logit_raw,
                'logit_difference': logit_difference
                #'true_rank': true_rank,
                #'predicted_rank': predicted_rank
            })

    except Exception as e:
        print(f"Failed to analyze prompt: {prompt}\nError: {e}", file=sys.stderr)
        return pd.DataFrame()
        
    return pd.DataFrame(all_metrics)

def analyze_attention_distinction(model, tokenizer, prompt_df, distractor_count=100):
    """
    Analyzes a DataFrame of prompts by computing the relative attention-extracted
    attribute information, I_a^(l)(o), for each layer as described by the paper.

    Args:
        model : The loaded model.
        tokenizer: The tokenizer.
        prompt_df : The DataFrame with prompts and emotions.
        distractor_count (int): The number of top tokens to use as distractors.

    Returns:
        pd.DataFrame: A DataFrame with the average distinction scores per layer.
    """
    all_metrics = []
    unembedding_matrix = model.unembed.W_U.squeeze() # Get the unembedding matrix
    
    for _, row in prompt_df.iterrows():
        try:
            true_emotion_text = row['emotion']
            prompt_text = row['constrained prompt']

            true_ids = get_token_ids(tokenizer, true_emotion_text)
            
            input_ids = tokenizer.encode(prompt_text, return_tensors='pt')
            final_token_idx = input_ids.shape[-1] - 1
            
            with torch.no_grad():
                logits, cache = model.run_with_cache(prompt_text)

            for layer_idx in range(model.cfg.n_layers):
                #Use the MLP output to find top distractors
                
                mlp_out_contribution = cache[("mlp_out", layer_idx)][0, final_token_idx, :]
                mlp_logits = model.unembed(mlp_out_contribution)
                
                #top N tokens that have high MLP-enriched information
                _, top_distractor_ids = torch.topk(mlp_logits, k=distractor_count)
                
                # the unembedding vectors for the true token and the distractors
                true_unembedding_vector = unembedding_matrix[true_ids].mean(dim=0)
                
                # the unembedding vectors for all top distractors
                distractor_unembedding_vectors = unembedding_matrix[top_distractor_ids]
                mean_distractor_vector = distractor_unembedding_vectors.mean(dim=0)
                
                # the difference vector (e_o - e_bar_o')
                distinction_vector = true_unembedding_vector - mean_distractor_vector
                
                #the attention output vector (a_T)
                attn_out_contribution = cache[("attn_out", layer_idx)][0, final_token_idx, :]
                
                # (a_T * (e_o - e_bar_o'))
                distinction_score = torch.dot(attn_out_contribution, distinction_vector).item()
                
                all_metrics.append({
                    'layer': layer_idx,
                    'distinction_score': distinction_score,
                })
                
        except Exception as e:
            print(f"Skipping analysis for prompt: {row['constrained prompt']}\nError: {e}", file=sys.stderr)
            continue

    if not all_metrics:
        print("No metrics were generated. The DataFrame might be empty or an error occurred.")
        return pd.DataFrame()
        
    all_metrics_df = pd.DataFrame(all_metrics)
    average_metrics_df = all_metrics_df.groupby('layer').mean().reset_index()
    
    return average_metrics_df

def analyze_final_embed_prompt_set(model, tokenizer, prompt_df):
    """
    Analyzes a DataFrame of prompts by calculating logit scores and ranks for each layer.
    
    Args:
        model : The Llama 2 model loaded with Transformer Lens.
        tokenizer: The tokenizer.
        prompt_df: The DataFrame containing 'constrained prompt',
                                    'emotion', and 'predicted emotion' columns.
                                    
    Returns:
        pd.DataFrame: A DataFrame with the average logit scores and ranks per layer.
    """
    all_metrics = []
    
    for _, row in prompt_df.iterrows():
        try:
            true_ids = get_token_ids(tokenizer, row['emotion'])
            predicted_ids = get_token_ids(tokenizer, row['prompt response'])
            
            input_ids = tokenizer.encode(row['constrained prompt'], return_tensors='pt')
            final_token_idx = input_ids.shape[-1] - 1
            
            
            with torch.no_grad():
                logits, cache = model.run_with_cache(row['constrained prompt'])

            for layer_idx in range(model.cfg.n_layers):
                #logit lens:
                current_residual_stream = cache[("resid_post", layer_idx)]
                layer_logits = model.ln_final(current_residual_stream)
                layer_logits = model.unembed(layer_logits)
                layer_logits_final_token = layer_logits[0, final_token_idx, :]
                
                # Sum of the logits for the true and predicted emotion tokens.
                true_logit_raw = layer_logits_final_token[true_ids].sum().item()
                predicted_logit_raw = layer_logits_final_token[predicted_ids].sum().item()
                logit_difference = predicted_logit_raw - true_logit_raw
                
                #the rank for the true and predicted tokens
                true_rank = get_rank(layer_logits_final_token, true_ids)
                predicted_rank = get_rank(layer_logits_final_token, predicted_ids)
                
                all_metrics.append({
                    'layer': layer_idx,
                    'true_logit_raw': true_logit_raw,
                    'predicted_logit_raw': predicted_logit_raw,
                    'logit_difference': logit_difference
                  
                })
        except Exception as e:
            print(f"Skipping analysis for prompt: {row['constrained prompt']}\nError: {e}")
            continue

    if not all_metrics:
        print("No metrics were generated. The prompt DataFrame might be empty or a tokenization error occurred.")
        return pd.DataFrame()
        
    all_metrics_df = pd.DataFrame(all_metrics)
    average_metrics_df = all_metrics_df.groupby('layer').mean().reset_index()
    
    return all_metrics_df, average_metrics_df

avg_logit_metrics_set1 = analyze_prompt_set_mlp_only(model_llama, model_llama.tokenizer, hallu_set1_df)

avg_logit_metrics_set2 = analyze_prompt_set_mlp_only(model_llama, model_llama.tokenizer, hallu_set2_df)

avg_logit_metrics_set3 = analyze_prompt_set_mlp_only(model_llama, model_llama.tokenizer, hallu_set3_df)

avg_logit_metrics_set4 = analyze_prompt_set_mlp_only(model_llama, model_llama.tokenizer, hallu_set4_df)

avg_logit_metrics_set5 = analyze_prompt_set_mlp_only(model_llama, model_llama.tokenizer, hallu_set5_df)

avg_logit_metrics_set6 = analyze_prompt_set_mlp_only(model_llama, model_llama.tokenizer, hallu_set6_df)

avg_logit_metrics_set7 = analyze_prompt_set_mlp_only(model_llama, model_llama.tokenizer, hallu_set7_df)

avg_logit_metrics_set8 = analyze_prompt_set_mlp_only(model_llama, model_llama.tokenizer, hallu_set8_df)

avg_logit_metrics_set9 = analyze_prompt_set_mlp_only(model_llama, model_llama.tokenizer, hallu_set9_df)

avg_logit_metrics_set10 = analyze_prompt_set_mlp_only(model_llama, model_llama.tokenizer, hallu_set10_df)


avg_logit_metrics_set11 = analyze_prompt_set_mlp_only(model_llama, model_llama.tokenizer, hallu_set11_df)

avg_logit_metrics_set12 = analyze_prompt_set_mlp_only(model_llama, model_llama.tokenizer, hallu_set12_df)

avg_logit_metrics_set13 = analyze_prompt_set_mlp_only(model_llama, model_llama.tokenizer, hallu_set13_df)

avg_logit_metrics_set14 = analyze_prompt_set_mlp_only(model_llama, model_llama.tokenizer, hallu_set14_df)

avg_logit_metrics_set15 = analyze_prompt_set_mlp_only(model_llama, model_llama.tokenizer, hallu_set15_df)

avg_logit_metrics_set16 = analyze_prompt_set_mlp_only(model_llama, model_llama.tokenizer, hallu_set16_df)

avg_logit_metrics_set17 = analyze_prompt_set_mlp_only(model_llama, model_llama.tokenizer, hallu_set17_df)

avg_logit_metrics_set18 = analyze_prompt_set_mlp_only(model_llama, model_llama.tokenizer, hallu_set18_df)

avg_logit_metrics_set19 = analyze_prompt_set_mlp_only(model_llama, model_llama.tokenizer, hallu_set19_df)

avg_logit_metrics_set20 = analyze_prompt_set_mlp_only(model_llama, model_llama.tokenizer, hallu_set20_df)


avg_logit_metrics_set_unknown = analyze_prompt_set_mlp_only(model_llama, model_llama.tokenizer, hallu_set20_df)

avg_logit_metrics_set1

all_avg_mlp_dfs = [
    avg_logit_metrics_set1, avg_logit_metrics_set2, avg_logit_metrics_set3,
    avg_logit_metrics_set4, avg_logit_metrics_set5, avg_logit_metrics_set6,
    avg_logit_metrics_set7, avg_logit_metrics_set8, avg_logit_metrics_set9,
    avg_logit_metrics_set10, avg_logit_metrics_set11, avg_logit_metrics_set12,
    avg_logit_metrics_set13, avg_logit_metrics_set14, avg_logit_metrics_set15,
    avg_logit_metrics_set16, avg_logit_metrics_set17, avg_logit_metrics_set18,
    avg_logit_metrics_set19, avg_logit_metrics_set20
]

hallucination_labels = [
    'joy-sadness', 'joy-love', 'joy-fear', 'joy-surprise', 'joy-anger',
    'anger-sadness', 'anger-joy', 'anger-fear', 'anger-love', 'anger-surprise',
    'sadness-fear', 'sadness-love', 'sadness-surprise', 'sadness-joy', 'sadness-anger',
    'fear-sadness', 'fear-love', 'fear-anger', 'fear-surprise', 'fear-joy',
    'joy-unknown'
]


combined_avg_mlp_df = pd.DataFrame()
for df, label in zip(all_avg_mlp_dfs, hallucination_labels):
    df['hallucination_type'] = label
    combined_avg_mlp_df = pd.concat([combined_avg_mlp_df, df])


heatmap_mlp_data = combined_avg_mlp_df.pivot(index='hallucination_type', columns='layer', values='logit_difference')


plt.figure(figsize=(16, 10))
sns.heatmap(heatmap_mlp_data, cmap='coolwarm', center=0, annot=False, fmt=".2f",
            linewidths=0.5, linecolor='gray', cbar_kws={'label': 'Average Logit Difference (y ratio)'})

plt.title('Average Hallucination Trajectories MLP', fontsize=16)
plt.xlabel('Layer Number', fontsize=14)
plt.ylabel('Hallucination Type', fontsize=14)
plt.yticks(rotation=0)
plt.tight_layout()
plt.show()

df_metrics_by_layer = pd.DataFrame(metrics_by_layer)
df_metrics_by_layer

df_final_embed_metrics1, df_avg_final_embed_metrics1 = analyze_final_embed_prompt_set(model_llama, tokenizer, hallu_set1_df)

df_final_embed_metrics1, df_avg_final_embed_metrics2 = analyze_final_embed_prompt_set(model_llama, tokenizer, hallu_set2_df)

df_final_embed_metrics1, df_avg_final_embed_metrics3 = analyze_final_embed_prompt_set(model_llama, tokenizer, hallu_set3_df)

df_final_embed_metrics1, df_avg_final_embed_metrics4 = analyze_final_embed_prompt_set(model_llama, tokenizer, hallu_set4_df)

df_final_embed_metrics1, df_avg_final_embed_metrics5 = analyze_final_embed_prompt_set(model_llama, tokenizer, hallu_set5_df)



df_final_embed_metrics1, df_avg_final_embed_metrics6 = analyze_final_embed_prompt_set(model_llama, tokenizer, hallu_set6_df)

df_final_embed_metrics1, df_avg_final_embed_metrics7 = analyze_final_embed_prompt_set(model_llama, tokenizer, hallu_set7_df)

df_final_embed_metrics1, df_avg_final_embed_metrics8 = analyze_final_embed_prompt_set(model_llama, tokenizer, hallu_set8_df)

df_final_embed_metrics1, df_avg_final_embed_metrics9 = analyze_final_embed_prompt_set(model_llama, tokenizer, hallu_set9_df)

df_final_embed_metrics1, df_avg_final_embed_metrics10 = analyze_final_embed_prompt_set(model_llama, tokenizer, hallu_set10_df)



df_final_embed_metrics1, df_avg_final_embed_metrics11 = analyze_final_embed_prompt_set(model_llama, tokenizer, hallu_set11_df)

df_final_embed_metrics1, df_avg_final_embed_metrics12 = analyze_final_embed_prompt_set(model_llama, tokenizer, hallu_set12_df)

df_final_embed_metrics1, df_avg_final_embed_metrics13 = analyze_final_embed_prompt_set(model_llama, tokenizer, hallu_set13_df)

df_final_embed_metrics1, df_avg_final_embed_metrics14 = analyze_final_embed_prompt_set(model_llama, tokenizer, hallu_set14_df)

df_final_embed_metrics1, df_avg_final_embed_metrics15 = analyze_final_embed_prompt_set(model_llama, tokenizer, hallu_set15_df)



df_final_embed_metrics1, df_avg_final_embed_metrics16 = analyze_final_embed_prompt_set(model_llama, tokenizer, hallu_set16_df)

df_final_embed_metrics1, df_avg_final_embed_metrics17 = analyze_final_embed_prompt_set(model_llama, tokenizer, hallu_set17_df)

df_final_embed_metrics1, df_avg_final_embed_metrics18 = analyze_final_embed_prompt_set(model_llama, tokenizer, hallu_set18_df)

df_final_embed_metrics1, df_avg_final_embed_metrics19 = analyze_final_embed_prompt_set(model_llama, tokenizer, hallu_set19_df)

df_final_embed_metrics1, df_avg_final_embed_metrics20 = analyze_final_embed_prompt_set(model_llama, tokenizer, hallu_set20_df)

df_avg_final_embed_metrics20

all_avg_dfs = [
    df_avg_final_embed_metrics1, df_avg_final_embed_metrics2, df_avg_final_embed_metrics3,
    df_avg_final_embed_metrics4, df_avg_final_embed_metrics5, df_avg_final_embed_metrics6,
    df_avg_final_embed_metrics7, df_avg_final_embed_metrics8, df_avg_final_embed_metrics9,
    df_avg_final_embed_metrics10, df_avg_final_embed_metrics11, df_avg_final_embed_metrics12,
    df_avg_final_embed_metrics13, df_avg_final_embed_metrics14, df_avg_final_embed_metrics15,
    df_avg_final_embed_metrics16, df_avg_final_embed_metrics17, df_avg_final_embed_metrics18,
    df_avg_final_embed_metrics19, df_avg_final_embed_metrics20
]

hallucination_labels = [
    'joy-sadness', 'joy-love', 'joy-fear', 'joy-surprise', 'joy-anger',
    'anger-sadness', 'anger-joy', 'anger-fear', 'anger-love', 'anger-surprise',
    'sadness-fear', 'sadness-love', 'sadness-surprise', 'sadness-joy', 'sadness-anger',
    'fear-sadness', 'fear-love', 'fear-anger', 'fear-surprise', 'fear-joy',
    'joy-unknown'
]


combined_df = pd.DataFrame()
for df, label in zip(all_avg_dfs, hallucination_labels):
    df['hallucination_type'] = label
    combined_df = pd.concat([combined_df, df])


heatmap_data = combined_df.pivot(index='hallucination_type', columns='layer', values='logit_difference')


plt.figure(figsize=(16, 10))
sns.heatmap(heatmap_data, cmap='coolwarm', center=0, annot=False, fmt=".2f",
            linewidths=0.5, linecolor='gray', cbar_kws={'label': 'Average Logit Difference (y ratio)'})

plt.title('Average Hallucination Trajectories', fontsize=16)
plt.xlabel('Layer Number', fontsize=14)
plt.ylabel('Hallucination Type', fontsize=14)
plt.yticks(rotation=0)
plt.tight_layout()
plt.show()

# --- Plot: Raw Logit Scores vs. Layer ---
plt.figure(figsize=(12, 7))


plt.plot(avg_logit_metrics_set1['layer'], avg_logit_metrics_set1['true_logit_raw'], label='True Emotion Logit', marker='o', linestyle='-', color='blue')
plt.plot(avg_logit_metrics_set1['layer'],avg_logit_metrics_set1['predicted_logit_raw'], label='Predicted Emotion Logit', marker='x', linestyle='--', color='orange')


plt.title('Average Raw Logit Scores Across All Layers Set 1 Joy->Sadness', fontsize=16)
plt.xlabel('Layers', fontsize=12)
plt.ylabel('Logit Score', fontsize=12)
plt.legend(fontsize=10)
plt.grid(True, which='both', linestyle=':', linewidth=0.5)


plt.axhline(0, color='black', linewidth=0.5)

plt.show()


plt.figure(figsize=(12, 7))


plt.plot(avg_logit_metrics_set1['layer'], avg_logit_metrics_set1['logit_difference'], label='Logit Difference (Predicted - True)', marker='s', linestyle='-', color='red')


plt.title('Average Logit Difference Across Layers', fontsize=16)
plt.xlabel('Layer', fontsize=12)
plt.ylabel('Logit Difference', fontsize=12)
plt.legend(fontsize=10)
plt.grid(True, which='both', linestyle=':', linewidth=0.5)


plt.axhline(0, color='black', linestyle='--', linewidth=0.8)

plt.show()

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[24], line 5
      2 plt.figure(figsize=(12, 7))
      4 # Plotting the raw logit scores for both emotions
----> 5 plt.plot(avg_logit_metrics_set1['layer'], avg_logit_metrics_set1['true_logit_raw'], label='True Emotion Logit', marker='o', linestyle='-', color='blue')
      6 plt.plot(avg_logit_metrics_set1['layer'],avg_logit_metrics_set1['predicted_logit_raw'], label='Predicted Emotion Logit', marker='x', linestyle='--', color='orange')
      8 # Adding titles, labels, and a legend

NameError: name 'avg_logit_metrics_set1' is not defined

<Figure size 1200x700 with 0 Axes>

# --- Plot: Raw Logit Scores vs. Layer ---
plt.figure(figsize=(12, 7))


plt.plot(avg_logit_metrics_set2['layer'], avg_logit_metrics_set2['true_logit_raw'], label='True Emotion Logit', marker='o', linestyle='-', color='blue')
plt.plot(avg_logit_metrics_set2['layer'],avg_logit_metrics_set2['predicted_logit_raw'], label='Predicted Emotion Logit', marker='x', linestyle='--', color='orange')


plt.title('Average Raw Logit Scores Across All Layers Set 2', fontsize=16)
plt.xlabel('Layers', fontsize=12)
plt.ylabel('Logit Score', fontsize=12)
plt.legend(fontsize=10)
plt.grid(True, which='both', linestyle=':', linewidth=0.5)


plt.axhline(0, color='black', linewidth=0.5)

plt.show()


plt.figure(figsize=(12, 7))


plt.plot(avg_logit_metrics_set2['layer'], avg_logit_metrics_set2['logit_difference'], label='Logit Difference (Predicted - True)', marker='s', linestyle='-', color='red')


plt.title('Average Logit Difference Across Layers', fontsize=16)
plt.xlabel('Layer', fontsize=12)
plt.ylabel('Logit Difference', fontsize=12)
plt.legend(fontsize=10)
plt.grid(True, which='both', linestyle=':', linewidth=0.5)


plt.axhline(0, color='black', linestyle='--', linewidth=0.8)

plt.show()

plt.figure(figsize=(12, 7))


plt.plot(avg_logit_metrics_set1['layer'], avg_logit_metrics_set3['true_logit_raw'], label='True Emotion Logit', marker='o', linestyle='-', color='blue')
plt.plot(avg_logit_metrics_set1['layer'],avg_logit_metrics_set3['predicted_logit_raw'], label='Predicted Emotion Logit', marker='x', linestyle='--', color='orange')


plt.title('Average Raw Logit Scores Across All Layers Set 1 Joy->Fear', fontsize=16)
plt.xlabel('Layers', fontsize=12)
plt.ylabel('Logit Score', fontsize=12)
plt.legend(fontsize=10)
plt.grid(True, which='both', linestyle=':', linewidth=0.5)


plt.axhline(0, color='black', linewidth=0.5)

plt.show()


plt.figure(figsize=(12, 7))


plt.plot(avg_logit_metrics_set1['layer'], avg_logit_metrics_set1['logit_difference'], label='Logit Difference (Predicted - True)', marker='s', linestyle='-', color='red')


plt.title('Average Logit Difference Across Layers', fontsize=16)
plt.xlabel('Layer', fontsize=12)
plt.ylabel('Logit Difference', fontsize=12)
plt.legend(fontsize=10)
plt.grid(True, which='both', linestyle=':', linewidth=0.5)


plt.axhline(0, color='black', linestyle='--', linewidth=0.8)

plt.show()

def calculate_prompt_ranks(model, tokenizer, prompt_df):
    """
    Analyzes a DataFrame of prompts by calculating the minimum rank for
    each prompt across all layers.
    """
    categorized_prompts = []
    
    for index, row in prompt_df.iterrows():
        try:
            true_emotion_text = row['emotion']
            prompt_text = row['constrained prompt']

            # token IDs for the true emotion
            true_ids = get_token_ids(tokenizer, true_emotion_text)
            
            input_ids = tokenizer.encode(prompt_text, return_tensors='pt')
            final_token_idx = input_ids.shape[-1] - 1
            
            with torch.no_grad():
                logits, cache = model.run_with_cache(prompt_text)

            min_true_rank_across_layers = float('inf')
            min_rank_layer_idx = -1
            
            for layer_idx in range(model.cfg.n_layers):
                # output of the MLP for the last token
                mlp_out_contribution = cache[("mlp_out", layer_idx)][0, final_token_idx, :]

                # MLP contribution through the unembedding matrix
                mlp_logits = model.unembed(mlp_out_contribution)
                
                # the rank for the true token
                true_rank = get_rank(mlp_logits, true_ids)
                
                # Update the minimum rank and the layer index
                if true_rank < min_true_rank_across_layers:
                    min_true_rank_across_layers = true_rank
                    min_rank_layer_idx = layer_idx
                
          
                
            categorized_prompts.append({
                'prompt': prompt_text,
                'rank last layer': true_rank,
                'min_true_rank': min_true_rank_across_layers,
                'min_rank_layer': min_rank_layer_idx
                
            })
            
        except Exception as e:
            print(f"Skipping analysis for row {index}. Error: {e}", file=sys.stderr)
            continue

    if not categorized_prompts:
        print("No prompts were categorized. The DataFrame might be empty or an error occurred.")
        return pd.DataFrame()
        
    categorized_df = pd.DataFrame(categorized_prompts)
        
    return categorized_df

%%time

prompt_ranks_df = calculate_prompt_ranks(model_llama, tokenizer, hallu_df)

CPU times: user 3min 10s, sys: 463 ms, total: 3min 11s
Wall time: 3min 14s

prompt_ranks_df

def categorize_prompts(ranked_df, threshold_strategy="average"):
    """
    Calculates the median of 'min_true_rank' as a threshold and
    categorizes the type of hallucination for each prompt.

    Args:
        ranked_df (pd.DataFrame): DataFrame containing prompt analysis with
                                   'min_true_rank' and other rank columns.

    Returns:
        pd.DataFrame: The original DataFrame with two new columns:
                      'threshold' and 'hallucination type'.
    """
    if ranked_df.empty:
        print("Input DataFrame is empty. Cannot categorize prompts.", file=sys.stderr)
        return ranked_df

    # Calculate the median of the 'min_true_rank' column to use as the threshold
    try:
        knowledge_threshold = np.median(ranked_df['min_true_rank'])
    except KeyError as e:
        print(f"DataFrame is missing the required column: {e}", file=sys.stderr)
        return ranked_df

    # Add the threshold as a new column for visibility
    ranked_df['threshold'] = knowledge_threshold

    # Define a function to assign the hallucination type
    def assign_category(min_rank):
        if min_rank <= knowledge_threshold:
            return "Extraction"
        else:
            return "Enrichment"

    # Apply the categorization function to create the new column
    ranked_df['hallucination type'] = ranked_df['min_true_rank'].apply(assign_category)
    
    if 'hallucination_type' in ranked_df.columns:
        ranked_df = ranked_df.drop(columns=['hallucination_type'])

    return ranked_df

categorized_hallu = categorize_prompts(prompt_ranks_df, threshold_strategy="median")

categorized_hallu#[categorized_hallu['hallucination type']=='Extraction'].count()

knowledge_threshold = 1


plt.figure(figsize=(10, 6))
plt.scatter(categorized_hallu['min_rank_layer'], categorized_hallu['min_true_rank'], alpha=0.8)


plt.yscale('log')


plt.axhline(y=knowledge_threshold, color='r', linestyle='--', label=f'Knowledge Threshold ({knowledge_threshold})')


plt.title('Minimum True Rank per Layer for Hallucinating Prompts', fontsize=16)
plt.xlabel('Layer Index (min rank)', fontsize=12)
plt.ylabel('Minimum True Rank (log scale)', fontsize=12)


plt.xticks(np.arange(0, categorized_hallu['min_rank_layer'].max() + 1, 1))


plt.grid(True, which="both", ls="--", c='0.7')


plt.legend()


plt.tight_layout()

# --- Plot : Distribution of Layers ---
plt.figure(figsize=(8, 5))
sns.histplot(data=categorized_hallu, x='min_rank_layer', kde=False, bins=20)
plt.title('Distribution of Layers with Minimum Rank')
plt.xlabel('Layer Index')
plt.ylabel('Num of Prompts')
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

plt.figure(figsize=(8, 5))
sns.kdeplot(data=categorized_hallu, x='min_true_rank', fill=True)
plt.title('Distribution of Minimum True Ranks')
plt.xlabel('Minimum True Rank')
plt.ylabel('Density')
plt.xscale('log') 
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

def analyze_and_categorize_prompts_attention_only(model, tokenizer, prompt_df, extraction_threshold=320):
    """
    Analyzes a DataFrame of prompts by calculating the minimum rank for
    the true emotion using an attention-only logit lens, then categorizes
    the hallucination type.

    Args:
        model : The loaded model.
        tokenizer: The tokenizer.
        prompt_df : The DataFrame with prompts and emotions.
        extraction_threshold (int): The rank threshold for a successful
                                    attention-based extraction.

    Returns:
        pd.DataFrame: A DataFrame with each prompt's calculated ranks
                      and categorized hallucination type.
    """
    categorized_prompts = []
    
    for index, row in prompt_df.iterrows():
        try:
            true_emotion_text = row['emotion']
            prompt_text = row['constrained prompt']

            #token IDs for the true emotion
            true_ids = get_token_ids(tokenizer, true_emotion_text)
            
            input_ids = tokenizer.encode(prompt_text, return_tensors='pt')
            final_token_idx = input_ids.shape[-1] - 1
            
            with torch.no_grad():
                logits, cache = model.run_with_cache(prompt_text)

            min_true_rank_across_layers = float('inf')
            min_rank_layer_idx = -1
            
            for layer_idx in range(model.cfg.n_layers):
               
                attn_out_contribution = cache[("attn_out", layer_idx)][0, final_token_idx, :]

                # attention contribution through the unembedding matrix
                attn_logits = model.unembed(attn_out_contribution)
                
                # rank for the true token based on the attention logits
                true_rank = get_rank(attn_logits, true_ids)
                
                # Update the minimum rank and the layer index
                if true_rank < min_true_rank_across_layers:
                    min_true_rank_across_layers = true_rank
                    min_rank_layer_idx = layer_idx
                
            
            if min_true_rank_across_layers < extraction_threshold:
                
                hallucination_type = "Enrichment"
            else:
               
                hallucination_type = "Extraction"
                
            categorized_prompts.append({
                'prompt': prompt_text,
                'min_true_rank': min_true_rank_across_layers,
                'min_rank_layer': min_rank_layer_idx,
                'hallucination_type': hallucination_type
            })
            
        except Exception as e:
            print(f"Skipping analysis for row {index}. Error: {e}", file=sys.stderr)
            continue

    if not categorized_prompts:
        print("No prompts were categorized. The DataFrame might be empty or an error occurred.")
        return pd.DataFrame()
        
    categorized_df = pd.DataFrame(categorized_prompts)
    
    return categorized_df

attn_categorized_df = analyze_and_categorize_prompts_attention_only(model_llama, model_llama.tokenizer, hallu_df)

attn_categorized_df#['min_true_rank'].max()

plt.figure(figsize=(10, 6))
plt.plot(range(model.cfg.n_layers), ranks_across_layers, marker='o', linestyle='-')
plt.axhline(y=320, color='r', linestyle='--', label=f'Knowledge Threshold ({320)')
            
plt.title(f'Rank of Correct Emotion ("{true_emotion_text}") Across MLP Layers\nPrompt {index}: {prompt_text[:50]}...')
plt.xlabel('Layer Number')
plt.ylabel('Rank (1-based)')
plt.yscale('log') 
plt.grid(True, which="both", linestyle='--', linewidth=0.5)
plt.legend()

avg_logit_metrics_set2['predicted_rank'].min()

1.3448275862068966

from collections import defaultdict



TARGET_SENTIMENTS = ['joy', 'sadness', 'anger', 'fear', 'surprise', 'disgust', 'love', 'amusement', 'excitement',
                     'happy', 'depressed', 'anxious', 'ecstatic', 'grief', 'calm', 'lonely', 'boredom',
                     'elation', 'hope', 'disappointment', 'confusion', 'relief']


COMMON_WORDS = [
    "the", "be", "to", "of", "and", "a", "in", "that", "have", "I", "it", "for", "not", "on", "with", "as", "do",
    "at", "this", "but", "by", "from", "up", "so", "what", "we", "he", "she", "they", "was", "one", "all", "can",
    "an", "is", "are", "you", "go", "new", "world", "time", "day", "night", "see", "man", "woman", "house", "car",
    "computer", "phone", "food", "music", "art", "book", "story", "game", "city", "country", "people", "thing",
    "life", "work", "school", "money", "power", "truth", "freedom", "justice", "peace", "war", "love", "hate",
    "friend", "family", "child", "adult", "animal", "plant", "water", "fire", "earth", "sky", "sun", "moon",
    "star", "space", "science", "math", "history", "language", "letter", "number", "idea", "thought", "feeling",
    "emotion", "mind", "body", "health", "beauty", "ugly", "good", "bad", "right", "wrong", "old", "young", "big",
    "small", "high", "low", "fast", "slow", "hot", "cold", "light", "dark", "open", "close", "start", "end",
    "begin", "finish", "like", "dislike", "know", "think", "feel", "want", "need", "find", "give", "take", "come",
    "go", "make", "do", "say", "tell", "ask", "answer", "look", "listen", "hear", "read", "write", "talk", "walk",
    "run", "jump", "fly", "swim", "eat", "drink", "sleep", "dream", "wake", "laugh", "cry", "smile", "frown",
    "win", "lose", "help", "thank", "sorry", "please", "maybe", "yes", "no", "why", "where", "when", "how",
    "always", "never", "often", "sometimes", "seldom", "today", "tomorrow", "yesterday"
]


FULL_VOCABULARY = sorted(list(set(TARGET_SENTIMENTS + COMMON_WORDS + [f"token_{i}" for i in range(10000)])))
VOCAB_SIZE = len(FULL_VOCABULARY)

simulated_scores = scores


print("\n--- Rho Star values for target sentiments ---")
for sentiment in TARGET_SENTIMENTS:
    rho_val = rho_star(simulated_scores, sentiment)
    print(f"ρ*('{sentiment}'): {rho_val:.4f}")


sorted_scores = sorted(simulated_scores.items(), key=lambda item: item[1], reverse=True)


print("\n--- Top 10 Ranked Tokens in Simulated Vocabulary ---")
for rank, (token, score) in enumerate(sorted_scores[:10]):
    print(f"Rank {rank + 1}: '{token}' (Score: {score:.2f})")

--- Rho Star values for target sentiments ---
ρ*('joy'): 0.5458
ρ*('sadness'): 0.0000
ρ*('anger'): 0.1730
ρ*('fear'): 0.3610
ρ*('surprise'): 0.0984
ρ*('disgust'): 0.3780
ρ*('love'): 0.9181
ρ*('amusement'): 0.5998
ρ*('excitement'): 0.5163
ρ*('happy'): 0.7960
ρ*('depressed'): 0.8262
ρ*('anxious'): 0.1330
ρ*('ecstatic'): 0.4559
ρ*('grief'): 0.0005
ρ*('calm'): 0.9812
ρ*('lonely'): 0.5216
ρ*('boredom'): 0.2403
ρ*('elation'): 0.4761
ρ*('hope'): 0.2018
ρ*('disappointment'): 0.8944
ρ*('confusion'): 0.8123
ρ*('relief'): 0.8297

--- Top 10 Ranked Tokens in Simulated Vocabulary ---
Rank 1: 'sadness' (Score: 6.69)
Rank 2: 'token_5621' (Score: 3.88)
Rank 3: 'token_9697' (Score: 3.72)
Rank 4: 'token_2826' (Score: 3.61)
Rank 5: 'token_6937' (Score: 3.57)
Rank 6: 'grief' (Score: 3.31)
Rank 7: 'token_9329' (Score: 3.30)
Rank 8: 'token_5258' (Score: 3.30)
Rank 9: 'token_4629' (Score: 3.28)
Rank 10: 'token_358' (Score: 3.27)

def get_emotion_token_ids(tokenizer, emotion_string):
    """
    Gets the token IDs for an emotion string by using the robust
    tokenizer.encode() method. This function handles both single and multi-token
    words and is less prone to failure than the tokenizer.tokenize() method.
    
    Args:
        tokenizer : The model's tokenizer.
        emotion_string (str): The emotion word to tokenize.
        
    Returns:
        list: A list of integers representing the token IDs for the emotion string.
        
    Raises:
        ValueError: If no tokens can be found for the emotion string.
    """
    encoded_with_space = tokenizer.encode(f" {emotion_string}", add_special_tokens=False)
    if encoded_with_space:
        return encoded_with_space
    
    encoded_without_space = tokenizer.encode(emotion_string, add_special_tokens=False)
    if encoded_without_space:
        return encoded_without_space
        
    raise ValueError(f"Could not find any tokens for '{emotion_string}'.")

def run_analysis_for_single_text(model, tokenizer, prompt, true_emotion, predicted_emotion):
    """
    Runs a layer-by-layer analysis for a single text and returns the results.
    This function now handles multi-token emotions by summing their logits.
    
    Args:
        model : The loaded language model.
        tokenizer : The model's tokenizer.
        prompt (str): The full input prompt for the model.
        true_emotion (str): The correct emotion label.
        predicted_emotion (str): The emotion predicted by the model.

    Returns:
        list: A list of dictionaries, where each dictionary contains the metrics
              for a single layer.
    """
    try:
        true_ids = get_emotion_token_ids(tokenizer, true_emotion)
        predicted_ids = get_emotion_token_ids(tokenizer, predicted_emotion)
        
        input_ids = tokenizer.to_tokens(prompt)
        final_token_idx = input_ids.shape[-1] - 1
        
        logits, cache = model.run_with_cache(input_ids)

        metrics_by_layer = []
        
        for layer_idx in range(model.cfg.n_layers + 1):
            
            current_residual_stream = cache[f'blocks.{layer_idx-1}.hook_resid_post'] if layer_idx > 0 else cache['hook_embed']
            layer_logits = model.unembed(model.ln_final(current_residual_stream))
            layer_logits_final_token = layer_logits[0, final_token_idx, :]
            
            true_logit = layer_logits_final_token[true_ids].sum().item()
            predicted_logit = layer_logits_final_token[predicted_ids].sum().item()
            
            metrics_by_layer.append({
                'layer': layer_idx,
                'true_logit_raw': true_logit,
                'predicted_logit_raw': predicted_logit
            })

    except Exception as e:
        print(f"Analysis failed for prompt: {prompt}\nError: {e}")
        metrics_by_layer = []
    
    return metrics_by_layer



try:
    model = HookedTransformer.from_pretrained(
        "meta-llama/Llama-2-7b-hf",
        fold_ln=False,
        center_unembed=False,
        center_writing_weights=False,
    )
    tokenizer = model.tokenizer
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token
    if torch.cuda.is_available():
        model.to('cuda')
    print("Model loaded for analysis.")
except Exception as e:
    print(f"Failed to load model: {e}")
 
    model = None
    tokenizer = None

print(f"\nVisualizing Average Attention to Final Token across All Layers and Heads ---")


num_layers = model_llama.cfg.n_layers
num_heads = model_llama.cfg.n_heads
    
    
seq_len = cache["pattern", 0].shape[-1]
final_token_index = seq_len - 1

  
avg_attention_matrix = torch.zeros((num_heads, num_layers))


for layer in range(num_layers):
        #attention pattern shape is (batch, num_heads, seq_len, seq_len)
    attention_patterns = cache["pattern", layer].squeeze()
        
    for head in range(num_heads):
 
        attention_to_final_token = attention_patterns[head, :, final_token_index]
            
        
        avg_attention = attention_to_final_token.mean()
            
           
        avg_attention_matrix[head, layer] = avg_attention

   
plot_data = avg_attention_matrix.detach().cpu().numpy()

    # Create the heatmap
plt.figure(figsize=(15, 10))
sns.heatmap(
        plot_data,
        cmap="viridis",
        linewidths=0.5,
        xticklabels=[f'L{i}' for i in range(num_layers)],
        yticklabels=[f'H{i}' for i in range(num_heads)],
        cbar_kws={'label': 'Average Attention to Final Token'}
    )
plt.title("Attention Weights on Final Token (All Layers and Heads)")
plt.xlabel("Layer Number")
plt.ylabel("Head Number")
plt.show()

layer_number = 10

attention_pattern_all_heads = cache["pattern", layer_number].squeeze().detach().cpu().numpy()
num_heads = attention_pattern_all_heads.shape[0]

input_tokens = tokenizer.tokenize(text_to_analyze)

fig, axes = plt.subplots(
        nrows=num_heads // 8, 
        ncols=8, 
        figsize=(20, 10), 
        constrained_layout=True
    )
    
  
axes = axes.flatten()
    
for i in range(num_heads):
    ax = axes[i]
    sns.heatmap(
        attention_pattern_all_heads[i], 
        xticklabels=input_tokens, 
        yticklabels=input_tokens,
        cmap="viridis",
        linewidths=0.2,
        ax=ax,
        cbar=False
        )
    ax.set_title(f'Head {i}')
    ax.tick_params(axis='x', rotation=90)
    ax.tick_params(axis='y', rotation=0)


fig.suptitle(f"Attention Heatmaps for Layer {layer_number}", fontsize=20)
fig.supxlabel("Key Tokens (Input)", fontsize=12)
fig.supylabel("Query Tokens (Output)", fontsize=12)
    
plt.show()

layer = 1
head = 1

attention_pattern = cache["pattern", layer]

print(attention_pattern.shape)
    


attention_to_plot = attention_pattern.squeeze().detach().cpu().numpy()[head]
    

input_tokens = tokenizer.tokenize(text_to_analyze)
    
print(f"\n Visualizing Attention Heatmap for Layer {layer}, Head {head} ---")
    
plt.figure(figsize=(10, 8))
sns.heatmap(attention_to_plot, 
            xticklabels=input_tokens, 
            yticklabels=input_tokens,
            cmap="viridis",
            linewidths=0.5)
plt.title(f"Attention Heatmap: Layer {layer}, Head {head}")
plt.xlabel("Key Tokens (Input)")
plt.ylabel("Query Tokens (Output)")
plt.show()

layer = 17
head = 14

attention_pattern = cache["pattern", layer]

print(attention_pattern.shape)
    


attention_to_plot = attention_pattern.squeeze().detach().cpu().numpy()[head]
    

input_tokens = tokenizer.tokenize(text_to_analyze)
    
print(f"\n Visualizing Attention Heatmap for Layer {layer}, Head {head} ---")
    
plt.figure(figsize=(10, 8))
sns.heatmap(attention_to_plot, 
            xticklabels=input_tokens, 
            yticklabels=input_tokens,
            cmap="viridis",
            linewidths=0.5)
plt.title(f"Attention Heatmap: Layer {layer}, Head {head}")
plt.xlabel("Key Tokens (Input)")
plt.ylabel("Query Tokens (Output)")
plt.show()

layer = 21
head = 24

attention_pattern = cache["pattern", layer]

print(attention_pattern.shape)
    

attention_to_plot = attention_pattern.squeeze().detach().cpu().numpy()[head]
    

input_tokens = tokenizer.tokenize(text_to_analyze)
    
print(f"\n Visualizing Attention Heatmap for Layer {layer}, Head {head} ---")
    
plt.figure(figsize=(10, 8))
sns.heatmap(attention_to_plot, 
            xticklabels=input_tokens, 
            yticklabels=input_tokens,
            cmap="viridis",
            linewidths=0.5)
plt.title(f"Attention Heatmap: Layer {layer}, Head {head}")
plt.xlabel("Key Tokens (Input)")
plt.ylabel("Query Tokens (Output)")
plt.show()

def get_model_embedding_layer(model):
    """
    Finds and returns the model's token embedding layer, handling various attribute names.
    """
    if hasattr(model, 'get_input_embeddings'):
        return model.get_input_embeddings
    elif hasattr(model, 'embed'):
        return model.embed
    elif hasattr(model, 'w_e'):
        return model.w_e
    else:
        raise AttributeError("Could not find the model's embedding layer or a valid embedding method (checked for 'get_input_embeddings', 'embed', and 'w_e').")
    
    
# --- Functions for calculating sigma and embeddings ---

def calculate_calibration_stats(model, tokenizer, prompts: List[str]) -> Tuple[float, torch.Tensor]:
    """
    Calculates sigma (3 * empirical std dev) and the mean embedding of a set of prompts.
    """
    all_embeddings = []
    
    # Process each prompt to get its embedding
    for prompt in prompts:
        input_ids = tokenizer(prompt, return_tensors="pt").input_ids
        
        with torch.no_grad():
            if hasattr(model, 'get_input_embeddings'):
                token_embeddings = model.get_input_embeddings()(input_ids)
            elif hasattr(model, 'embed'):
                token_embeddings = model.embed(input_ids)
            else:
                raise AttributeError("Could not find the model's embedding layer or a valid embedding method.")
        
        mean_embedding = torch.mean(token_embeddings, dim=1)
        all_embeddings.append(mean_embedding.squeeze())
        
    stacked_embeddings = torch.stack(all_embeddings)

    # Calculate the standard deviation and mean of all embeddings
    empirical_std_dev = torch.std(stacked_embeddings, dim=0, unbiased=False)
    mean_embedding = torch.mean(stacked_embeddings, dim=0)

    # Calculate sigma as 3 times the mean of the std dev vector
    sigma = 3 * torch.mean(empirical_std_dev).item()
    
    return sigma, mean_embedding

calibration_prompts = hallu_df['constrained prompt'].tolist()

sigma_value, mean_embedding_vector = calculate_calibration_stats(model_llama, tokenizer, calibration_prompts)

print("Sigma:", sigma_value)
mean_embedding_vector

Sigma: 0.0028929677791893482

tensor([-1.3256e-03,  2.9094e-03,  1.5659e-05,  ...,  4.5183e-04,
        -1.7084e-04,  8.3932e-04], device='cuda:0')

def find_subject_token(tokenizer, prompt):
    """
    Finds the first token of a prompt, assuming it represents the subject.
    """
    # 1. Clean the prompt by stripping leading/trailing quotes and spaces
    clean_prompt = prompt.strip(' \'"')
    
    # 2. Use the tokenizer to get the token IDs for the cleaned prompt
    input_ids = tokenizer.encode(clean_prompt, add_special_tokens=False)
    
    # Handle empty prompts after cleaning
    if not input_ids:
        return ""
        
    # 3. Get the ID of the first token
    first_token_id = input_ids[0]
    
    # 4. Decode the ID back to a string to get the token text
    first_token_text = tokenizer.decode(first_token_id)
    
    # 5. Return the first token text, stripping any leading spaces
    return first_token_text.strip()

# Example usage with your provided prompt from the DataFrame
prompt_from_df = hallu_df['constrained prompt'].iloc[59]

# The function will now handle the cleaning automatically
subject_text = find_subject_token(tokenizer, prompt_from_df)
print(f"The subject token is: '{subject_text}'")

The subject token is: 'i'

 hallu_df['constrained prompt'].iloc[55]

'i journaled about my tendency to sometimes overcommit myself which can make me feel exhausted and overwhelmed\nWhat the single emotion of this text? You must choose one and only one from the following list: sadness, joy, love, anger, fear, surprise. The emotion is:'

def get_perturbed_embeddings(model, tokenizer, prompt, sigma):
    """
    Calculates u* by adding scaled Gaussian noise to the embedding of the
    first token in the prompt, which is assumed to be the subject.

    Args:
        model: The loaded TransformerLens model.
        tokenizer: The tokenizer for the model.
        prompt (str): The original prompt text.
        sigma (float): The calculated standard deviation for the noise.

    Returns:
        torch.Tensor: The perturbed input embeddings (u*).
    """
    # 1. Cleaning the prompt by stripping leading/trailing quotes and spaces
    clean_prompt = prompt.strip(' \'"')
    input_ids = tokenizer.encode(clean_prompt, return_tensors='pt')
    
    if input_ids.numel() == 0:
        print("Warning: Prompt is empty after cleaning. Cannot generate embeddings.")
        return None

    # Getting the original embeddings from the model's embedding layer
    with torch.no_grad():
        original_embeddings = model.embed(input_ids)
        
   
    subject_token_index = 0
    
    # 2. Creating Gaussian noise scaled by sigma
    noise = torch.randn_like(original_embeddings) * sigma
    
    # 3. Creating a new tensor for u* by copying the original embeddings
    u_star_embeddings = original_embeddings.clone()
    
    # 4. Injecting the noise into the subject token's embedding
    u_star_embeddings[0, subject_token_index, :] += noise[0, subject_token_index, :]
    
    return u_star_embeddings

u_star = get_perturbed_embeddings(model_llama, tokenizer,  hallu_df['constrained prompt'].iloc[55], sigma_value)

u_star.shape

torch.Size([1, 65, 4096])

u_star_tensors = {}  # This dictionary will store all your u* tensors

# Loop through each row of your hallucination DataFrame
for index, row in hallu_set1_df.iterrows():
    prompt = row['constrained prompt']
    
    # Calculate u* for the current prompt
    perturbed_embeddings = get_perturbed_embeddings(model_llama, tokenizer, prompt, sigma_value)
    
    # Check if the embeddings were successfully generated
    if perturbed_embeddings is not None:
        # Store the tensor in the dictionary with the prompt's index as the key
        u_star_tensors[index] = perturbed_embeddings

print(f"Stored {len(u_star_tensors)} u* tensors for analysis.")

Stored 114 u* tensors for analysis.

def perform_causal_analysis_y_prime(model, tokenizer, hallu_df, sigma_value, num_noise_samples):
    """
    Performs a more memory-efficient causal analysis by optimizing
    the generation of noise samples.
    """
    results_df = pd.DataFrame(columns=['prompt_text', 'true_emotion', 'predicted_emotion', 'num_truth_inducing_samples', 'truthful_y_primes'])

   
    with torch.no_grad():
        for index, row in hallu_df.iterrows():
            prompt_to_analyze = row['constrained prompt'].strip()
            true_emotion = row['emotion']
            predicted_emotion = row['predicted emotion']
            
            
            truthful_y_primes = []
            
            # 1. Running the original prompt once to get the original embeddings
            _, original_cache = model.run_with_cache(prompt_to_analyze)
            original_embeddings = original_cache['embed'].clone().detach()
            
            # clearing the cache to free up memory before the noise sampling loop starts
            del original_cache
            torch.cuda.empty_cache()

            # 2. token IDs for the true and predicted emotions once
            try:
                true_id = tokenizer.encode(true_emotion, add_special_tokens=False)[0]
                predicted_id = tokenizer.encode(predicted_emotion, add_special_tokens=False)[0]
            except IndexError:
                print(f"Skipping prompt {index}: Emotion token not found.")
                continue

            # 3. Using a single noise tensor for all samples to minimize memory allocation
            
            
            for _ in range(num_noise_samples):
                # Adding noise to the original embeddings to get u*
            
                subject_token_index = 0
                noise = torch.randn_like(original_embeddings) * sigma_value
                perturbed_embeddings = original_embeddings.clone()
                perturbed_embeddings[0, subject_token_index, :] += noise[0, subject_token_index, :]
                
                # Using a hook to replace the 'embed' output with the perturbed embeddings
                def hook_fn_replace_embed(embed_output, hook):
                    return perturbed_embeddings
                
                # Running the model with the hook
                new_logits = model.run_with_hooks(
                    input=tokenizer.encode(prompt_to_analyze, return_tensors='pt'),
                    fwd_hooks=[('hook_embed', hook_fn_replace_embed)]
                )
                
                # Computing the new log-likelihood ratio (y') from the new logits
                final_logits = new_logits[0, -1, :]
                y_prime = final_logits[predicted_id] - final_logits[true_id]
                
                # Filtering for "truth-inducing" samples
                if y_prime.item() < 1:
                    truthful_y_primes.append(y_prime.item())

            
            new_row = pd.DataFrame([{
                'prompt_text': prompt_to_analyze,
                'true_emotion': true_emotion,
                'predicted_emotion': predicted_emotion,
                'num_truth_inducing_samples': len(truthful_y_primes),
                'truthful_y_primes': truthful_y_primes
            }])
            results_df = pd.concat([results_df, new_row], ignore_index=True)
            
            # free memory after each prompt
            del original_embeddings
            torch.cuda.empty_cache()

    return results_df

%%time 

y_prime1 = perform_causal_analysis_y_prime(model_llama, tokenizer, hallu_set1_df, sigma_value, num_noise_samples=100)

CPU times: user 20min 45s, sys: 56.5 s, total: 21min 42s
Wall time: 21min 41s

y_prime1

y_prime1[(y_prime1['num_truth_inducing_samples']>50)]

%%time 


y_prime2 = perform_causal_analysis_y_prime(model_llama, tokenizer, hallu_set2_df, sigma_value, num_noise_samples=100)

CPU times: user 12min 10s, sys: 37.6 s, total: 12min 47s
Wall time: 12min 47s

y_prime2

%%time 


y_prime3 = perform_causal_analysis_y_prime(model_llama, tokenizer, hallu_set3_df, sigma_value, num_noise_samples=100)

y_prime3

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[62], line 1
----> 1 y_prime3

NameError: name 'y_prime3' is not defined

%%time 


y_prime4 = perform_causal_analysis_y_prime(model_llama, tokenizer, hallu_set4_df, sigma_value, num_noise_samples=100)

y_prime4

%%time 


y_prime5 = perform_causal_analysis_y_prime(model_llama, tokenizer, hallu_set5_df, sigma_value, num_noise_samples=100)

y_prime5

%%time 


y_prime6 = perform_causal_analysis_y_prime(model_llama, tokenizer, hallu_set6_df, sigma_value, num_noise_samples=100)

CPU times: user 11min 50s, sys: 37.6 s, total: 12min 28s
Wall time: 12min 27s

y_prime6

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[63], line 1
----> 1 y_prime6

NameError: name 'y_prime6' is not defined

%%time 


y_prime7 = perform_causal_analysis_y_prime(model_llama, tokenizer, hallu_set7_df, sigma_value, num_noise_samples=100)

CPU times: user 4min 51s, sys: 18.7 s, total: 5min 10s
Wall time: 5min 10s

y_prime7

%%time 


y_prime8 = perform_causal_analysis_y_prime(model_llama, tokenizer, hallu_set8_df, sigma_value, num_noise_samples=100)

CPU times: user 1min 37s, sys: 5.02 s, total: 1min 42s
Wall time: 1min 41s

y_prime8

%%time 


y_prime9 = perform_causal_analysis_y_prime(model_llama, tokenizer, hallu_set9_df, sigma_value, num_noise_samples=100)

CPU times: user 1min 39s, sys: 6.19 s, total: 1min 45s
Wall time: 1min 45s

y_prime9

%%time 


y_prime10 = perform_causal_analysis_y_prime(model_llama, tokenizer, hallu_set10_df, sigma_value, num_noise_samples=100)

CPU times: user 33.5 s, sys: 2 s, total: 35.5 s
Wall time: 35.5 s

y_prime10

%%time 


y_prime11 = perform_causal_analysis_y_prime(model_llama, tokenizer, hallu_set10_df, sigma_value, num_noise_samples=100)

CPU times: user 33.4 s, sys: 1.94 s, total: 35.3 s
Wall time: 35.3 s

y_prime11

%%time 


y_prime12 = perform_causal_analysis_y_prime(model_llama, tokenizer, hallu_set10_df, sigma_value, num_noise_samples=100)

CPU times: user 33.3 s, sys: 2.12 s, total: 35.4 s
Wall time: 35.4 s

y_prime12

%%time 


y_prime13 = perform_causal_analysis_y_prime(model_llama, tokenizer, hallu_set10_df, sigma_value, num_noise_samples=100)

CPU times: user 33.3 s, sys: 2.09 s, total: 35.4 s
Wall time: 35.4 s

y_prime13

%%time 


y_prime14 = perform_causal_analysis_y_prime(model_llama, tokenizer, hallu_set10_df, sigma_value, num_noise_samples=100)

CPU times: user 33.3 s, sys: 2.11 s, total: 35.4 s
Wall time: 35.4 s

y_prime14

%%time 


y_prime15 = perform_causal_analysis_y_prime(model_llama, tokenizer, hallu_set10_df, sigma_value, num_noise_samples=100)

CPU times: user 33.4 s, sys: 2.2 s, total: 35.6 s
Wall time: 35.6 s

y_prime15

%%time 


y_prime16 = perform_causal_analysis_y_prime(model_llama, tokenizer, hallu_set10_df, sigma_value, num_noise_samples=100)

CPU times: user 33.3 s, sys: 2.11 s, total: 35.4 s
Wall time: 35.4 s

y_prime16

%%time 


y_prime17 = perform_causal_analysis_y_prime(model_llama, tokenizer, hallu_set10_df, sigma_value, num_noise_samples=100)

CPU times: user 33.3 s, sys: 2.1 s, total: 35.4 s
Wall time: 35.4 s

y_prime17

%%time 


y_prime18 = perform_causal_analysis_y_prime(model_llama, tokenizer, hallu_set10_df, sigma_value, num_noise_samples=100)

CPU times: user 33.3 s, sys: 2.14 s, total: 35.4 s
Wall time: 35.4 s

y_prime18

%%time 


y_prime19 = perform_causal_analysis_y_prime(model_llama, tokenizer, hallu_set10_df, sigma_value, num_noise_samples=100)

CPU times: user 33.2 s, sys: 2.18 s, total: 35.4 s
Wall time: 35.4 s

y_prime19

%%time 


y_prime20 = perform_causal_analysis_y_prime(model_llama, tokenizer, hallu_set10_df, sigma_value, num_noise_samples=100)

CPU times: user 33.4 s, sys: 2.04 s, total: 35.4 s
Wall time: 35.4 s

y_prime20

def get_target_token_indices(tokenizer, prompt, target_tokens):
    """
    Finds the token indices for all occurrences of the target tokens in a prompt.
    """
    input_ids = tokenizer.encode(prompt, add_special_tokens=False)
    target_indices = [
        i for i, token_id in enumerate(input_ids)
        if tokenizer.decode(token_id).strip().lower() in target_tokens
    ]
    return target_indices

target_emotional_tokens = ['abandoned', 'abandonment', 'abhor', 'abhorrent', 'aberration', 'abduction', 'ability', 'abba', 
                           'abbot', 'affecting', 'affective', 'affiliate', 'affirm', 'affirmation', 'affirmative', 'afflict', 
                           'afflicted', 'affliction', 'affluence', 'afford', 'affront', 'afraid', 'afresh', 'aftermath', 'agape', 
                           'aggressor', 'aggravate', 'aggravating', 'aggression', 'aggressive', 'aggressiveness', 'aghast', 'agitate', 
                           'agitated', 'agitation', 'agony', 'agree', 'agreeable', 'agreed', 'agreement', 'alarm', 'alarming', 'albatross', 
                           'alert', 'alienate', 'alienated', 'alienation', 'alive', 'allegiance', 'alleviate', 'alone', 'amazement', 'amazed', 
                           'amazing', 'ambition', 'ambitious', 'ameliorate', 'amusement', 'amusing', 'anarchism', 'anarchist', 'anarchy', 'angel', 
                           'angelic', 'anger', 'angry', 'anguish', 'animosity', 'annoy', 'annoyance', 'annoying', 'anomaly', 'antagonism', 'antagonist',
                           'antagonistic', 'anxiety', 'anxious', 'apathetic', 'apathy', 'apologize', 'apology', 'appeal', 'appealing', 'appease', 'applaud', 
                           'applause', 'appreciation', 'appreciative', 'apprehensive', 'apprehension', 'approved', 'arrogance', 'arrogant', 'ashamed', 'assault',
                           'assassination', 'assure', 'assured', 'astonished', 'astonishing', 'astonishment', 'atrocious', 'atrocity', 'aversion', 'avert', 'avid',
                           'awful', 'awkward', 'backfire', 'bad', 'baffle', 'baffled', 'bafflement', 'baleful', 'ballyhoo', 'banter', 'baseless', 'beautiful', 
                           'beauty', 'beg', 'beguile', 'belittle', 'belligerence', 'belligerent', 'benefit', 'beneficial', 'benevolence', 'benevolent', 'bereaved',
                           'bereavement', 'bestial', 'betray', 'betrayal', 'bicker', 'bickering', 'bitter', 'bitterness', 'blackmail', 'blame', 'blight', 'bliss',
                           'blissful', 'boast', 'boredom', 'bother', 'brave', 'bravery', 'breakthrough', 'bribery', 'bright', 'brilliant', 'brutal', 'brutality',
                           'bully', 'calamity', 'calm', 'calmness', 'canonize', 'captivate', 'care', 'careful', 'carefully', 'caress', 'catastrophe', 'celebrate',
                           'celebration', 'certain', 'certainty', 'chagrin', 'charity', 'charm', 'charming', 'cheer', 'cheerful', 'cheerless', 'cheery', 'cherish',
                           'clash', 'coerce', 'coercion', 'collapse', 'comfort', 'comfortable', 'compasionate', 'compassion', 'complacent', 'complaint', 'compliment',
                           'complimentary', 'composure', 'confess', 'confession', 'confidence', 'confident', 'conflict', 'confound', 'confrontation', 'confuse', 
                           'confused', 'confusion', 'congratulate', 'congratulation', 'conspiracy', 'contagion', 'contagious', 'contempt', 'contemptible', 
                           'contemptuous', 'contentment', 'corrupt', 'corruption', 'courage', 'courageous', 'covetous', 'cower', 'cramped', 'crash', 'crave', 
                           'craving', 'crazed', 'crazy', 'crush', 'crying', 'cynical', 'damage', 'daring', 'darkness', 'dastardly', 'dauntless', 'dead', 'dear',
                           'dearth', 'death', 'decay', 'deceit', 'deceitful', 'deceive', 'deception', 'defeat', 'defeated', 'defect', 'defective', 'defense',
                           'defenseless', 'defer', 'defiance', 'deficient', 'deformity', 'dejected', 'dejection', 'delay', 'delight', 'delighted', 'demise', 
                           'demolition', 'demon', 'denounce', 'denunciation', 'deny', 'deplete', 'deplorable', 'depravity', 'depressed', 'depression', 'deprive', 
                           'deprived', 'deserve', 'desirable', 'desire', 'despair', 'desperate', 'desperation', 'despicable', 'despise', 'destroy', 'destruction', 
                           'despondent', 'despondency', 'detest', 'detestable', 'devastate', 'devastating', 'devil', 'devilish', 'devotion', 'devout', 'difficult', 
                           'difficulty', 'disagree', 'disagreement', 'disappointed', 'disappointment', 'disapprove', 'disapproval', 'disaster', 'disastrous',
                           'disbelief', 'discomfort', 'discontent', 'discontented', 'discord', 'discourage', 'disgust', 'disgusted', 'disgusting', 'dishearten', 
                           'disheveled', 'dishonest', 'dishonesty', 'dishonor', 'disintegrate', 'dislike', 'dismal', 'dismay', 'dismayed', 'displeased', 
                           'displeasure', 'disrespect', 'disrespectful', 'distress', 'distressed', 'distrust', 'disturb', 'divorce', 'dominant', 'doubt',
                           'dread', 'dreadful', 'dull', 'eager', 'ecstasy', 'elation', 'eloquence', 
                           'embrace', 'emotional', 'empty', 'enchantment', 'encouragement', 'endearing', 'enjoy', 'enjoyment', 'enrage', 'enraged', 'entice',
                           'entitlement', 'enthusiasm', 'enthusiastic', 'envy', 'evil', 'exasperation', 'excite', 'excited', 'excitement', 'exhausted', 'exuberant',
                           'fabulous', 'faint', 'faith', 'faithful', 'falsify', 'famish', 'fanatic', 'fantastic', 'fear', 'fearful', 'fearless', 'fearsome', 
                           'feeble', 'felicity', 'ferocious', 'fiery', 'fight', 'filthy', 'flagging', 'flatter', 'flattery', 'flustered', 'foe', 'fondness', 
                           'fool', 'foolish', 'forgive', 'forgiveness', 'forlorn', 'fortunate', 'fortune', 'foul', 'frantic', 'frenzy', 'friend', 'friendly', 
                           'fright', 'frightened', 'frightening', 'frown', 'frustrate', 'frustrated', 'frustration', 'furious', 'fury', 'gallant', 'gaudy', 
                           'ghastly', 'giddy', 'gloom', 'gloomy', 'glorious', 'glory', 'grief', 'grieving', 'grimace', 'gross', 'grotesque', 'guilt', 'guilty',
                           'hapless', 'happiness', 'happy', 'harass', 'harm', 'harsh', 'hatred', 'haunt', 'haunted', 'heartbreak', 'heartbreaking', 'heartless',
                           'heaven', 'hell', 'helpless', 'hesitation', 'hideous', 'hope', 'hopeful', 'hopeless', 'hopelessness', 'horrendous', 'horrible', 'horror',
                           'humiliate', 'humiliation', 'hurt', 'hymn', 'idiot', 'ignorant', 'ill', 'illness', 'imbecile', 'immortal', 'impatient', 'important', 
                           'inability', 'inadequate', 'incensed', 'incite', 'indignant', 'indignation', 'infatuated', 'infatuation', 'infection', 'inferior',
                           'inferno', 'infuriate', 'infuriated', 'infuriating', 'insane', 'insanity', 'insidious', 'insult', 'insulting', 'integrity', 'interest',
                           'interested', 'invasion', 'invigorate', 'involve', 'irk', 'jealousy', 'jest', 'jinx', 'jovial', 'joy', 'joyful', 'jubilation', 'karma', 
                           'kidnap', 'kindness', 'lack', 'lament', 'lamentation', 'laugh', 'laughter', 'leisure', 'liberation', 'liberty', 'lie', 'light', 'like',
                           'love', 'loyal', 'loyalty', 'ludicrous', 'lust', 'maddening', 'madness', 'malaise', 'malice', 'malignant', 'maniac', 'massacre', 
                           'menace', 'merciless', 'mercy', 'mirth', 'misery', 'mishap', 'mistake', 'molestation', 'monstrous', 'morbid', 'mourn', 'mournful', 
                           'murder', 'mutiny', 'nasty', 'nausea', 'nauseating', 'neglect', 'neglected', 'neglectful', 'nerve', 'nervous', 'nightmare',
                           'obnoxious', 'obscene', 'offend', 'offense', 'ominous', 'optimism', 'optimistic', 'outrage', 'outrageous', 'overjoy',
                           'panic', 'paradise', 'passion', 'patience', 'peace', 'peaceful', 'pessimistic', 'pity', 'plague', 'pleasant', 'pleasure',
                           'poison', 'poisonous', 'praise', 'pride', 'promising', 'protest', 'proud', 'rage', 'rape', 'rapport', 'rascal', 'relieve', 
                           'relief', 'remorse', 'remorseful', 'resentment', 'respect', 'revenge', 'revulsion', 'ridiculous', 'rigid', 'risk', 'sadness', 
                           'safe', 'safety', 'salvation', 'sanguine', 'sarcasm', 'savage', 'scare', 'scared', 'scary', 'scream', 'screaming', 'screech', 
                           'secure', 'sensational', 'sensitive', 'serene', 'sham', 'shame', 'shattered', 'shock', 'shocking', 'shriek', 'sick', 'sickness', 
                           'sincere', 'sincerity', 'sneer', 'solemn', 'sorrow', 'sorrowful', 'spectacular', 'splendid', 'squalor', 'stab', 'startle', 'startling',
                           'strangle', 'stupid', 'suffering', 'suffocate', 'superb', 'surprise', 'surprised', 'suspense', 'suspicious', 'swindle', 'sympathy', 
                           'terror', 'terrible', 'terrific', 'terrified', 'threat', 'threaten', 'thrilled', 'thrilling', 'tragedy', 'tragic', 'triumph',
                           'triumphant', 'trust', 'trusted', 'trusting', 'ugly', 'uncomfortable', 'unhappiness', 'unhappy', 'uninspired', 'unpleasant', 
                           'upset', 'upsetting', 'vengeance', 'vicious', 'victory', 'violent', 'want', 'wary', 'weak', 'weakness', 'weep', 'weeping', 'welcome',
                           'woe', 'wonderful', 'worry', 'wretched', 'wrong', 'wrongdoing', 'yearning', 'yell', 'zest']

def perform_causal_analysis_emotional_tokens(model, tokenizer, prompt_df, sigma_value, num_noise_samples, target_tokens):
    """
    Performs causal analysis by adding scaled Gaussian noise to the embeddings of
    emotionally charged tokens, testing if this intervention reduces the hallucination.

    Args:
        model (HookedTransformer): The loaded TransformerLens model.
        tokenizer: The tokenizer for the model.
        hallu_df (pd.DataFrame): DataFrame containing hallucinated prompts.
        sigma_value (float): The standard deviation for the Gaussian noise.
        num_noise_samples (int): The number of noise samples to test per prompt.
        target_tokens (list): A list of emotionally charged words to target for noise injection.

    Returns:
        pd.DataFrame: A DataFrame with the results of the analysis, including
                      the number of "truth-inducing" samples and their y' values.
    """
    results_df = pd.DataFrame(columns=['prompt_text', 'true_emotion', 'predicted_emotion', 'num_truth_inducing_samples', 'truthful_y_primes'])

    # Ensure no gradients are computed to save memory and computation
    with torch.no_grad():
        for index, row in prompt_df.iterrows():
            prompt_to_analyze = row['constrained prompt']
            true_emotion = row['emotion']
            predicted_emotion = row['predicted emotion']
            
            # Find all indices of the target emotional tokens
            target_indices = get_target_token_indices(tokenizer, prompt_to_analyze, target_tokens)
            
            # Skip if no target tokens are found in this prompt
            if not target_indices:
                print(f"Skipping prompt {index}: No target tokens found.")
                continue

            truthful_y_primes = []
            
            # 1. Running the original prompt once to get the original embeddings
            _, original_cache = model.run_with_cache(prompt_to_analyze.strip())
            original_embeddings = original_cache['embed'].clone().detach()
            
            # Clear the cache to free up memory before the noise sampling loop starts
            del original_cache
            torch.cuda.empty_cache()

            # 2. Get token IDs for the true and predicted emotions once
            try:
                # Some tokenizers prepend a space, so we check for both cases
                true_id_with_space = tokenizer.encode(" " + true_emotion, add_special_tokens=False)[0]
                predicted_id_with_space = tokenizer.encode(" " + predicted_emotion, add_special_tokens=False)[0]
                true_id_no_space = tokenizer.encode(true_emotion, add_special_tokens=False)[0]
                predicted_id_no_space = tokenizer.encode(predicted_emotion, add_special_tokens=False)[0]
            except IndexError:
                print(f"Skipping prompt {index}: Emotion token not found.")
                continue
            
            for _ in range(num_noise_samples):
                # Add noise to the original embeddings to get u*
                noise = torch.randn_like(original_embeddings) * sigma_value
                perturbed_embeddings = original_embeddings.clone()

                # Iterate through the found indices and add noise to each one
                for token_idx in target_indices:
                    perturbed_embeddings[0, token_idx, :] += noise[0, token_idx, :]
                
                # Using a hook to replace the 'embed' output with the perturbed embeddings
                def hook_fn_replace_embed(embed_output, hook):
                    return perturbed_embeddings
                
                # Running the model with the hook
                new_logits = model.run_with_hooks(
                    input=tokenizer.encode(prompt_to_analyze.strip(), return_tensors='pt'),
                    fwd_hooks=[('hook_embed', hook_fn_replace_embed)]
                )
                
                # Computing the new log-likelihood ratio (y') from the new logits
                final_logits = new_logits[0, -1, :]
                
                # We try both possible token IDs to be safe
                if (predicted_id_with_space in final_logits and true_id_with_space in final_logits):
                    y_prime = final_logits[predicted_id_with_space] - final_logits[true_id_with_space]
                elif (predicted_id_no_space in final_logits and true_id_no_space in final_logits):
                    y_prime = final_logits[predicted_id_no_space] - final_logits[true_id_no_space]
                else:
                    # If neither token is in the vocab, we skip this sample
                    continue
                
                # Filtering for "truth-inducing" samples where y' < 1
                if y_prime.item() < 1:
                    truthful_y_primes.append(y_prime.item())

            new_row = pd.DataFrame([{
                'prompt_text': prompt_to_analyze,
                'true_emotion': true_emotion,
                'predicted_emotion': predicted_emotion,
                'num_truth_inducing_samples': len(truthful_y_primes),
                'truthful_y_primes': truthful_y_primes
            }])
            results_df = pd.concat([results_df, new_row], ignore_index=True)
            
            # Free memory after each prompt
            del original_embeddings
            torch.cuda.empty_cache()

    return results_df

%%time

y_prime1_H2 = perform_causal_analysis_emotional_tokens(model_llama, tokenizer, hallu_set1_df, sigma_value, 100, target_emotional_tokens)

y_prime1_H2

	layer	true_logit_raw	predicted_logit_raw	logit_difference
0	0	0.042862	0.049106	0.006244
1	1	-0.032123	-0.030466	0.001657
2	2	0.009539	0.022680	0.013142
3	3	0.039212	0.036289	-0.002923
4	4	0.018332	-0.000224	-0.018556
5	5	-0.024541	-0.037068	-0.012527
6	6	0.099670	0.104609	0.004939
7	7	0.047168	0.061052	0.013883
8	8	-0.123419	-0.269522	-0.146102
9	9	-0.067410	-0.194566	-0.127156
10	10	0.206784	0.177669	-0.029115
11	11	-0.071258	-0.011496	0.059762
12	12	0.009501	-0.124627	-0.134128
13	13	0.208407	-0.040961	-0.249368
14	14	0.147578	0.105679	-0.041900
15	15	-0.208594	-0.028600	0.179993
16	16	0.066571	0.347009	0.280438
17	17	-0.397830	-0.219520	0.178311
18	18	0.170615	1.107536	0.936920
19	19	-0.071143	-0.087341	-0.016198
20	20	0.649218	0.868288	0.219070
21	21	0.100348	0.036048	-0.064300
22	22	1.409741	3.419079	2.009338
23	23	-0.061976	-0.115207	-0.053231
24	24	1.095231	0.731112	-0.364119
25	25	0.252596	0.295253	0.042657
26	26	1.490949	1.023902	-0.467046
27	27	0.613216	0.617208	0.003991
28	28	1.525975	2.174344	0.648369
29	29	1.339956	2.106903	0.766946
30	30	0.615736	0.734725	0.118989
31	31	2.926512	2.888888	-0.037623

	layer	true_logit_raw	predicted_logit_raw	logit_difference
0	0	0.013213	-0.013995	-0.027208
1	1	-0.011127	-0.053295	-0.042168
2	2	0.021379	-0.009150	-0.030529
3	3	-0.000348	0.056553	0.056900
4	4	-0.051777	0.002234	0.054011
5	5	0.022064	-0.020254	-0.042319
6	6	-0.060282	-0.254970	-0.194688
7	7	-0.217798	-0.023091	0.194707
8	8	-0.037718	-0.180274	-0.142557
9	9	0.131731	-0.052067	-0.183797
10	10	0.075860	0.195145	0.119285
11	11	0.149734	-0.315545	-0.465279
12	12	0.307045	0.323456	0.016410
13	13	-0.278175	-0.269717	0.008458
14	14	0.344058	-0.347963	-0.692021
15	15	0.046988	0.008356	-0.038632
16	16	0.136274	-0.206019	-0.342292
17	17	0.156708	0.274397	0.117689
18	18	-0.065126	0.142009	0.207135
19	19	0.141014	-0.213396	-0.354410
20	20	0.183370	0.008092	-0.175278
21	21	-0.142685	-0.325537	-0.182853
22	22	-0.140620	-0.031544	0.109077
23	23	0.228008	0.507865	0.279857
24	24	0.288440	0.104584	-0.183855
25	25	-0.115407	-0.389410	-0.274004
26	26	0.076005	0.335583	0.259578
27	27	-0.152765	0.423250	0.576016
28	28	0.630913	0.273599	-0.357314
29	29	0.710369	1.108987	0.398618
30	30	5.201483	5.359866	0.158383
31	31	5.894176	8.212970	2.318794

	layer	true_logit_raw	predicted_logit_raw	logit_difference
0	0	-4.017740	-3.972081	0.045659
1	1	-6.302462	-3.602907	2.699555
2	2	-3.037071	-0.592533	2.444539
3	3	0.128028	1.154666	1.026638
4	4	2.252389	0.755388	-1.497001
5	5	1.839278	1.394928	-0.444351
6	6	0.087958	0.567913	0.479955
7	7	2.298635	1.576388	-0.722247
8	8	-0.308488	-1.020296	-0.711808
9	9	-0.211918	-0.188982	0.022935
10	10	3.451856	1.401170	-2.050687
11	11	1.559031	1.226814	-0.332217
12	12	2.805185	1.607053	-1.198132
13	13	1.382388	-0.750837	-2.133224
14	14	1.643309	0.709412	-0.933898
15	15	2.521628	0.511647	-2.009981
16	16	3.311272	2.609924	-0.701348
17	17	5.172476	5.112270	-0.060206
18	18	5.074670	5.331038	0.256369
19	19	4.743002	4.864981	0.121979
20	20	4.905226	5.848854	0.943627
21	21	3.590213	6.225431	2.635218
22	22	3.605882	9.163173	5.557291
23	23	7.237650	11.230175	3.992525
24	24	6.110950	11.567355	5.456405
25	25	6.417862	13.603354	7.185492
26	26	6.797778	13.283780	6.486002
27	27	7.834819	13.930937	6.096118
28	28	9.633776	16.177731	6.543955
29	29	11.222052	19.962515	8.740463
30	30	17.811695	27.199028	9.387333
31	31	25.333031	29.637125	4.304094

	layer	true_logit_raw	predicted_logit_raw	logit_difference
0	0	-2.873863	-0.758869	2.114994
1	1	-3.704048	-1.539252	2.164796
2	2	0.290379	0.992199	0.701820
3	3	0.383301	1.721965	1.338663
4	4	-2.081966	-0.300618	1.781348
5	5	-1.767304	0.533669	2.300973
6	6	-1.756042	0.993260	2.749302
7	7	-2.148143	-1.018185	1.129958
8	8	-4.218505	-4.284214	-0.065709
9	9	-4.650069	-2.506237	2.143832
10	10	-2.693636	0.271739	2.965376
11	11	-1.003915	-0.756746	0.247169
12	12	0.376597	0.198659	-0.177937
13	13	-1.451785	-0.861481	0.590304
14	14	-0.987878	0.298898	1.286776
15	15	-0.997821	0.130630	1.128451
16	16	1.412097	2.016400	0.604303
17	17	1.415749	2.747323	1.331574
18	18	2.582456	2.507748	-0.074708
19	19	2.819668	1.532712	-1.286956
20	20	3.324880	4.520706	1.195826
21	21	2.936024	4.495245	1.559221
22	22	6.374737	6.461772	0.087035
23	23	5.773640	7.428059	1.654419
24	24	5.770026	7.885203	2.115177
25	25	6.610858	9.417770	2.806912
26	26	7.119132	9.501991	2.382860
27	27	7.162617	9.194077	2.031460
28	28	9.145814	12.437756	3.291941
29	29	11.291294	14.341504	3.050210
30	30	19.157683	25.365045	6.207362
31	31	27.132079	38.063740	10.931661

Data preprocessing¶

Initialising Model¶

Convert logits to a distribution with softmax¶

Constraint based prompting¶

Mechanistic Interpretibility¶

Joy Hallucinations (True Emotion: Joy)¶

Anger Hallucinations (True Emotion: Anger)¶

Sadness Hallucinations (True Emotion: Sadness)¶

Fear Hallucinations (True Emotion: Fear)¶

Generate logits and cache for all the hallu prompt samples¶

Logit Lens¶

Attention Heatmap¶

Causal Validation¶

Hypothesis on adding noises to which embedding tokens as to why the model is hallucinating.¶

	text	emotion	constrained prompt	prompt response	predicted emotion	Output status
0	im feeling rather rotten so im not very ambiti...	sadness	im feeling rather rotten so im not very ambiti...	sadness	sadness	1
1	im updating my blog because i feel shitty	sadness	im updating my blog because i feel shitty\nWha...	sadness	sadness	1
2	i never make her separate from me because i do...	sadness	i never make her separate from me because i do...	love.	love	0
3	i left with my bouquet of red and yellow tulip...	joy	i left with my bouquet of red and yellow tulip...	optimism	unknown	0
4	i was feeling a little vain when i did this one	sadness	i was feeling a little vain when i did this on...	i was feeling a little vain when i	unknown	0
...	...	...	...	...	...	...
1995	i just keep feeling like someone is being unki...	anger	i just keep feeling like someone is being unki...	anger	anger	1
1996	im feeling a little cranky negative after this...	anger	im feeling a little cranky negative after this...	negative	unknown	0
1997	i feel that i am useful to my people and that ...	joy	i feel that i am useful to my people and that ...	joy	joy	1
1998	im feeling more comfortable with derby i feel ...	joy	im feeling more comfortable with derby i feel ...	comfort	unknown	0
1999	i feel all weird when i have to meet w people ...	fear	i feel all weird when i have to meet w people ...	sadness	sadness	0

	prompt	rank last layer	min_true_rank	min_rank_layer	threshold	hallucination type
0	i never make her separate from me because i do...	3	1	28	1.0	Extraction
1	i left with my bouquet of red and yellow tulip...	102	1	30	1.0	Extraction
2	i was feeling a little vain when i did this on...	1	1	31	1.0	Extraction
3	i cant walk into a shop anywhere where i do no...	1735	1	30	1.0	Extraction
4	i explain why i clung to a relationship with a...	14	1	30	1.0	Extraction
...	...	...	...	...	...	...
1211	i had that kinda feeling but ignored it\nWhat ...	2	1	30	1.0	Extraction
1212	i dont blame it all to them and im not angry a...	2308	1	30	1.0	Extraction
1213	im feeling a little cranky negative after this...	29	2	30	1.0	Enrichment
1214	im feeling more comfortable with derby i feel ...	5	2	30	1.0	Enrichment
1215	i feel all weird when i have to meet w people ...	3887	1	30	1.0	Extraction

	prompt	min_true_rank	min_rank_layer	hallucination_type
0	'i never make her separate from me because i d...	2	31	Enrichment
1	'i left with my bouquet of red and yellow tuli...	3	31	Enrichment
2	'i was feeling a little vain when i did this o...	3	31	Enrichment
3	'i explain why i clung to a relationship with ...	3	31	Enrichment
4	'i jest i feel grumpy tired and pre menstrual ...	3	31	Enrichment
...	...	...	...	...
1125	'i came out of the airport that makes me feel ...	5	22	Enrichment
1126	'i wasnt feeling sociable i really wasnt'What ...	8	31	Enrichment
1127	'i dont blame it all to them and im not angry ...	1	22	Enrichment
1128	'im feeling a little cranky negative after thi...	3	28	Enrichment
1129	'i feel all weird when i have to meet w people...	1	22	Enrichment

	prompt_text	true_emotion	predicted_emotion	num_truth_inducing_samples	truthful_y_primes
0	i survey my own posts over the last few years ...	joy	sadness	0	[]
1	i spent wandering around still kinda dazed and...	joy	sadness	0	[]
2	i hate that i m sitting here at the hostel wri...	joy	sadness	0	[]
3	i am feeling better though i dont sound it\nWh...	joy	sadness	0	[]
4	i feel like i know who most of them are by now...	joy	sadness	100	[0.10139751434326172, 0.2326068878173828, 0.13...
...	...	...	...	...	...
109	i am thinking is the fact because xanax slows ...	joy	sadness	0	[]
110	i guess it could be described as me just not r...	joy	sadness	0	[]
111	i dont really care and i dont feel proud of my...	joy	sadness	0	[]
112	i don t know what to feel as in i am not sure ...	joy	sadness	0	[]
113	i wasnt feeling sociable i really wasnt\nWhat ...	joy	sadness	0	[]

	prompt_text	true_emotion	predicted_emotion	num_truth_inducing_samples	truthful_y_primes
0	i explain why i clung to a relationship with a...	joy	love	0	[]
1	i think they have always been proponents of th...	joy	love	0	[]
2	i feel like i am in paradise kissing those swe...	joy	love	0	[]
3	i really like this person feel that the questi...	joy	love	0	[]
4	i am being over dramatic but i do feel very st...	joy	love	0	[]
...	...	...	...	...	...
61	i chance that difficult to accommodate with th...	joy	love	0	[]
62	i feel the presence of the divine with you whe...	joy	love	0	[]
63	i feel is an acceptable and significant modern...	joy	love	5	[0.9637012481689453, 0.7831516265869141, 0.928...
64	i feel that bassanio is sincere about wooing p...	joy	love	0	[]
65	i was feeling especially brave and asked me to...	joy	love	0	[]

	prompt_text	true_emotion	predicted_emotion	num_truth_inducing_samples	truthful_y_primes
0	i feel rather privileged to have witnessed the...	joy	surprise	100	[-0.5713939666748047, -0.5586872100830078, -0....
1	i do feel welcomed but it s a little weird\nWh...	joy	surprise	0	[]
2	i feel amused looking at the little turtle who...	joy	surprise	96	[0.7917404174804688, 0.8727140426635742, 0.912...
3	i had one of my low carb meal bars for breakfa...	joy	surprise	0	[]
4	i assumed it would feel casual\nWhat the singl...	joy	surprise	100	[0.47569751739501953, 0.562718391418457, 0.483...
5	i was truly surprised and feel quite honored\n...	joy	surprise	0	[]
6	i found myself being amazed at how mid s f wou...	joy	surprise	0	[]

	prompt_text	true_emotion	predicted_emotion	truthful_y_primes
0	i feel that he is so determined to steal priva...	joy	anger	[]
1	i feel strong is that i dont let the anger win...	joy	anger	[]
2	i am feeling contented and pissed at the same ...	joy	anger	[]
3	i guess it comes from believing that when i wa...	joy	anger	[]
4	i swear and i mean this if the browns fail me ...	joy	anger	[]
5	i am not feeling so generous and he is sent to...	joy	anger	[]

	prompt_text	true_emotion	predicted_emotion	num_truth_inducing_samples	truthful_y_primes
0	i guess i wont feel too jealous since i often ...	anger	joy	0	[]
1	i feel like my irritable sensitive combination...	anger	joy	0	[]
2	i didnt feel i rushed things dhawan tweet scri...	anger	joy	0	[]
3	i tasted some hari raya cookies and feeling gr...	anger	joy	0	[]
4	i buy something i go out and look at what else...	anger	joy	100	[-0.6309471130371094, -0.6317272186279297, -1....
5	i started feeling a little stressed about leav...	anger	joy	0	[]
6	i feel like i m finally losing that stubborn l...	anger	joy	0	[]
7	i feel like i should be listening to chinesepo...	anger	joy	0	[]
8	whenever i put myself in others shoes and try ...	anger	joy	0	[]
9	i was lying in bed last night after a day of m...	anger	joy	100	[-4.0432891845703125, -4.089033126831055, -4.0...
10	i wish i could bottle her squeals of delight a...	anger	joy	0	[]
11	i can cycle further than ever before and the f...	anger	joy	0	[]
12	i read her blog is that i feel that shes one p...	anger	joy	0	[]
13	i feel its rude to say he is better than all t...	anger	joy	0	[]
14	i feel like a greedy pig catching up to do lt ...	anger	joy	0	[]
15	i feel completely rude with not keeping up wit...	anger	joy	0	[]
16	i did not want to feel rushed through the prog...	anger	joy	0	[]
17	i don t really believe because i walked throug...	anger	joy	100	[-0.33954811096191406, -0.34633445739746094, -...
18	i needed some space i needed to grow i was in ...	anger	joy	100	[-4.152190208435059, -4.313880920410156, -4.28...
19	i lie down he feels my belly listens to babys ...	anger	joy	0	[]
20	i went outside to shut in the hens then was te...	anger	joy	0	[]
21	i feel like it add a little bit more shield fr...	anger	joy	0	[]
22	i didnt want to be spending my days working in...	anger	joy	0	[]
23	i have to admit that i feel the teensiest bit ...	anger	joy	0	[]
24	i was feeling pretty distracted with a few thi...	anger	joy	0	[]
25	im able to refine my poses and concepts withou...	anger	joy	0	[]

	prompt_text	true_emotion	predicted_emotion	truthful_y_primes
0	i feel it is dangerous especially for the new ...	anger	fear	[]
1	i feel like it s waiting in the wings just pat...	anger	fear	[]
2	i feel like i fucked up big time but i have to...	anger	fear	[]
3	i feel that it is extremely dangerous for her ...	anger	fear	[]
4	i have this really bad feeling that cold is wh...	anger	fear	[]
5	i have felt the need to write out my sometimes...	anger	fear	[]
6	i am sat here feeling mightily distracted and ...	anger	fear	[]
7	i get the feeling that this could be dangerous...	anger	fear	[]
8	i felt apprehensive in regards to the party of...	anger	fear	[]

	prompt_text	true_emotion	predicted_emotion	truthful_y_primes
0	i loved about ellie is that she didnt feel ins...	anger	love	[]
1	i asked her what she meant by shes gonna feel ...	anger	love	[]
2	i love that this is a place a series with no r...	anger	love	[]
3	i hope it is because he understands the way i ...	anger	love	[]
4	i am starting to feel like maybe i do want a r...	anger	love	[]
5	i feel like they rushed the relationship\nWhat...	anger	love	[]
6	at a party i met a girl who drew me to her\nWh...	anger	love	[]
7	i am not feeling the love towards myself and t...	anger	love	[]
8	i was feeling cold towards to my partner altho...	anger	love	[]

	prompt_text	true_emotion	predicted_emotion	truthful_y_primes
0	when a friend dropped a frog down my neck\nWha...	anger	surprise	[]
1	i was quite surprised with the weather these p...	anger	surprise	[]
2	i started to feel like i was going mad as i wa...	anger	surprise	[]